diff options
| author | Eirik Aavitsland <eirik.aavitsland@theqtcompany.com> | 2015-04-09 14:06:37 (GMT) |
|---|---|---|
| committer | aavit <eirik.aavitsland@theqtcompany.com> | 2015-04-12 21:07:07 (GMT) |
| commit | a16695f45f8de7608584937d5b4df34613eb0685 (patch) | |
| tree | dcd8454ded44057f9e2fdcd7cde010231e1316a6 /src/3rdparty/libtiff | |
| parent | 35c968f8582783884936d9e8e8421d75c369b172 (diff) | |
| download | Qt-a16695f45f8de7608584937d5b4df34613eb0685.zip Qt-a16695f45f8de7608584937d5b4df34613eb0685.tar.gz Qt-a16695f45f8de7608584937d5b4df34613eb0685.tar.bz2 | |
Update bundled libtiff to version 4.0.3
This updates libtiff.pri and 3rdparty/libtiff to the current state in
the Qt 5 qtimageformats module, commit
c3035a1655090b0f6b194fb8a7586c013ef24f6a. The patch history relative
to upstream 4.0.3 is available in that module.
Change-Id: I70d278081c62ba179c5f9658a0d59313c77ba415
Reviewed-by: Liang Qi <liang.qi@theqtcompany.com>
Reviewed-by: Lars Knoll <lars.knoll@digia.com>
Diffstat (limited to 'src/3rdparty/libtiff')
206 files changed, 17369 insertions, 40032 deletions
diff --git a/src/3rdparty/libtiff/ChangeLog b/src/3rdparty/libtiff/ChangeLog index 20cb753..a537f71 100644 --- a/src/3rdparty/libtiff/ChangeLog +++ b/src/3rdparty/libtiff/ChangeLog @@ -1,6 +1,904 @@ +2012-09-22 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * libtiff 4.0.3 released. + +2012-09-20 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * Makefile.am: Update to Automake 1.12.4 + +2012-08-19 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * Makefile.in: Update to Automake 1.12.3 + + * libtiff{tiff.h, tif_print.c, tif_dirinfo.c, tif_dirread.c}: Add + some TIFF/FX support in libtiff. Add the tag definitions to + tiff.h. Add the related TIFF field definitions to tif_dirinfo.c, + and also fixes an error in a comment. Adds the photometric values + to tif_print.c, and fixes a bug. These changes are by Steve + Underwood. + +2012-08-13 Frank Warmerdam <warmerdam@google.com> + + * libtiff/tif_write.c: Fix bug rewriting image tiles in a + compressed file: http://trac.osgeo.org/gdal/ticket/4771 + +2012-08-02 Frank Warmerdam <warmerdam@google.com> + + * libtiff/tif_dirread.c: report error in case of mismatch value + counts for tags (ie. DotRange). + +2012-07-26 Tom Lane <tgl@sss.pgh.pa.us> + + * libtiff/{tiffio.h, tif_dirinfo.c, libtiff.def}: Add six new + functions TIFFFieldTag(), TIFFFieldName(), TIFFFieldDataType(), + TIFFFieldPassCount(), TIFFFieldReadCount(), TIFFFieldWriteCount() + as external accessors for the opaque type TIFFField. + + * tools/tiffset.c: Make tiffset use the above functions instead of + relying on library private headers. + +2012-07-19 Tom Lane <tgl@sss.pgh.pa.us> + + * tools/tiff2pdf.c: Fix two places where t2p_error didn't get set + after a malloc failure. No crash risk AFAICS, but the program + might not report exit code 1 as desired. h/t mancha@mac.hush.com + +2012-07-18 Tom Lane <tgl@sss.pgh.pa.us> + + * tools/tiff2pdf.c: Fail when TIFFSetDirectory() fails. This + prevents core dumps or perhaps even arbitrary code execution when + processing a corrupt input file (CVE-2012-3401). + +2012-07-06 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * test/raw_decode.c (main): Test fixes to work with IJG JPEG 7+. + IJG JPEG 7+ uses a different upsampling algorithm which produces + different numeric results. + + * libtiff/tif_jpeg.c (JPEGPreDecode): Patch from Even Rouault to + work with IJG JPEG 7+. + +2012-07-04 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * test/raw_decode.c: Add changes so that test can run with build + directory outside of source directory. + +2012-07-02 Frank Warmerdam <warmerdam@google.com> + + * libtiff/tif_jpeg.c: Fix handling when writing RGBA jpeg compressed + imagery (http://trac.osgeo.org/gdal/ticket/4732) + +2012-06-20 Frank Warmerdam <warmerdam@google.com> + + * libtiff/tif_fax3.c: fix memory initialization of runs, only + partly done. + + * libtiff/tif_pixarlog.c: Make sure tbuf is large enough for one + full "stride" past the end. + +2012-06-19 Frank Warmerdam <warmerdam@google.com> + + * libtiff/tif_packbits.c: fix read past end of data buffer. + +2012-06-15 Frank Warmerdam <warmerdam@google.com> + + * libtiff 4.0.2 released. + + * tools/tif2pdf.c, tools/tifdump.c: avoid unitialized variable + warnings with clang. + +2012-06-15 Tom Lane <tgl@sss.pgh.pa.us> + + * tools/tiff2pdf.c: Defend against integer overflows while + calculating required buffer sizes (CVE-2012-2113). + +2012-06-12 Frank Warmerdam <warmerdam@google.com> + + * libtiff/tif_print.c: Be careful about printing corrupt inknames. + + * libtiff/tif_fax3.c: Ensure runs array is initialized to zeros. + +2012-06-07 Frank Warmerdam <warmerdam@google.com> + + * libtiff/tif_print.c: avoid pretty printing other fields when + we don't have the proper amount and type of data or if the field + is actually autodefined. + +2012-06-05 Frank Warmerdam <warmerdam@google.com> + + * libtiff/tif_tile.c, libtiff/tif_strip.c: Ensure that illegal + ycbcrsubsampling values result in a runtime error, not just an + assertion. + + * tests/custom_dir.c: Add testing of EXIF and custom directory + reading and writing. + + * libtiff/tif_dir.c, libtiff/tiffio.h: Add TIFFCreateCustomDirectory() + and TIFFCreateEXIFDirectory() functions. + + * libtiff/tif_dir.c, tif_print.c : Remove FIELD_CUSTOM handling for + PAGENUMBER, HALFTONEHINTS, and YCBCRSUBSAMPLING. Implement DOTRANGE + differently. This is to avoid using special TIFFGetField/TIFFSetField + rules for these fields in non-image directories (like EXIF). + +2012-06-04 Frank Warmerdam <warmerdam@google.com> + + * libtiff/tif_jpeg.c: Remove code for fixing up h_sampling and v_sampling + in JPEGPreDecode(). If a fixup will be done it needs to be done sooner + in JPEGFixupTagsSubsampling() or else buffer sized may be wrong. + +2012-06-01 Frank Warmerdam <warmerdam@google.com> + + * tools/tiffinfo.c: Do not try to read image data in EXIF directories. + + * libtiff/tif_getimage.c: added support for _SEPARATED CMYK images. + http://bugzilla.maptools.org/show_bug.cgi?id=2379 + + * libtiff/tif_unix.c: use strerror() to return a more specific error message + on failed open. + http://bugzilla.maptools.org/show_bug.cgi?id=2341 + + * libtiff/tif_jpeg.c: Fix JPEGDecodeRaw() bugs. + http://bugzilla.maptools.org/show_bug.cgi?id=2386 + + * tests/decode_raw.c, tests/images/quad-tile.jpg.tiff: add limited support + for testing jpeg in tiff image decoding including the "raw" decode interface. + +2012-05-31 Frank Warmerdam <warmerdam@google.com> + + * libtiff/tif_jpeg.c: avoid overrunning the end of the output buffer in + JPEGDecodeRaw() - mostly likely to occur when there is confusion about + sampling values. + + * libtiff/tif_read.c: Make sure tif_rawdatasize is cleared when tif_rawdata is freed. + + * libtiff/tif_getimage.c: Add support for greyscale+alpha c/o Jérémie Laval. + http://bugzilla.maptools.org/show_bug.cgi?id=2398 + +2012-05-29 Frank Warmerdam <warmerdam@google.com> + + * libtiff/tif_dir.c: avoid using specific set/get logic to process fields in custom directories, + like EXIF directories. This fixes problems like a tag "320" existing in a custom directory getting + processed as if it were a colormap when it isn't really. Damn the wide variety of argument formulations + to get/set functions for different tags! + + * libtiff/tif_dir.c: Ensure that we keep track of when tif_rawdata + is a pointer into an mmap()ed file via TIFF_BUFFERMMAP flag. + +2012-05-24 Frank Warmerdam <warmerdam@google.com> + + * libtiff/tif_pixarlog.c: Allocate working buffer one word larger since we "forward + accumulate" and overwrite the end by one word in at least some cases. + +2012-05-23 Frank Warmerdam <warmerdam@google.com> + + * libtiff/tif_pixarlog.c: avoid accessing out of the lookup arrays for out of range inputs. + + * tools/tiffinfo.c: initialize h=0 to avoid undefined variable for degenerate files. + + * libtiff/tif_ojpeg.c: if OJPEGWriteHeader() fails once do not bother trying again on + the same image. + + * libtiff/tif_ojpeg.c: make things more resilient in the face of files without + stripbytecounts or stripoffsets or where loading these fails. + + * libtiff/tif_print.c: be careful about whether min/max values are singular + or one per sample. + + * libtiff/tif_print.c: Avoid confusion about count size when printing custom fields. + May affect things like ISOSpeedRatings. + + * libtiff/tif_dir.c: avoid one byte past end of ink names reading + in some cases. + +2012-05-19 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * man/TIFFGetField.3tiff: Correct the 'count' field type in the + example for how to retreive the value of unsupported tags. + +2012-03-30 Frank Warmerdam <warmerdam@google.com> + + * tif_getimage.c: Fix size overflow (zdi-can-1221,CVE-2012-1173) + care of Tom Lane @ Red Hat. + +2012-02-18 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * libtiff 4.0.1 released. + + * Update automake used to 1.11.3. + + * libtiff/tiffio.h: Use double-underbar syntax in GCC printf + attribute specification to lessen the risk of accidental macro + substitution. Patch from Vincent Torri. + +2012-01-31 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_dir.c, libtiff/tif_dirread.c: Extra caution around + assumption tag fetching is always successful. + + * libtiff/tif_jpeg.c: Extra caution for case where sp is NULL. + +2012-01-22 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * configure.ac: Add support for using library symbol versioning on + ELF systems with the GNU linker. Support is enabled via + --enable-ld-version-script. Disabled by default for now until + there is a decision for how to deploy a libtiff with versioned + symbols after libtiff 4.0.0 was already released. + +2011-12-22 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * libtiff/tif_win32.c: Eliminate some minor 64-bit warnings in + + tif_win32.c. Patch by Edward Lam. + + * configure.ac: Add libtiff private dependency on -llzma for + pkg-config. Patch by Mark Brand. + Updated Automake to 1.11.2. + +2011-12-21 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * libtiff 4.0.0 released. + +2011-12-08 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_dirread.c, libtiff/tif_read.c: more cautious checking + of _TIFFFillStriles() results (#gdal 4372) + +2011-12-07 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_dirread.c: fixes to deal with invalid files where + _TIFFFillStriles() fails, and we try to chop up strips (gdal #4372) + + * libtiff/tif_dirread.c: fix error reporting when there is no + tag information struct and name (gdal #4373) + +2011-10-22 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * Update GNU libtool to 2.4.2. + + * tools/tiffsplit.c (tiffcp): TIFFGetField count field should be + uint32 type for TIFFTAG_JPEGTABLES. Patch by Christophe + Deroulers. + +2011-06-21 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/libtiff.def: Restore TIFFMergeFieldInfo. + +2011-05-31 Jim Meyering <meyering@redhat.com> + + * libtiff/tif_dirread.c (TIFFFetchStripThing): Free "data" also + upon failure to allocate "resizeddata". + * tools/tiff2ps.c (PSDataBW): Zero buffer *after* checking for + allocation failure, not before. + * libtiff/tif_ojpeg.c: plug leaks on OJPEG read failure path + * tools/rgb2ycbcr.c (cvtRaster): unchecked malloc + * libtiff/tif_jpeg.c, tools/tiff2pdf.c, tools/tiff2ps.c: mark + NULL-deref and possible overflow + * tools/tiff2pdf.c: remove decl+set of set-but-not-used local, "written" + * libtiff/tif_jpeg.c (JPEGInitializeLibJPEG): Remove declaration + and set of otherwise unused local, data_is_empty. + * libtiff/tif_jpeg.c (JPEGDecodeRaw) [JPEG_LIB_MK1_OR_12BIT]: + Diagnose out-of-memory failure and return 0 rather than + dereferencing NULL. + +2011-05-24 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_dirread.c: produce special error message for zero tag + directories instead of error out on the malloc(0) failure. + +2011-05-16 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_dirinfo.c: Restore TIFFMergeFieldInfo() and + related declarations as they are in active use by libraries + such as libgeotiff, and work just fine. (#2315) + +2011-04-20 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_dirinfo.c,tiffio.h: Remove the obsolete + TIFFMergeFieldInfo/TIFFFindFieldInfo/TIFFFindFieldInfoByName API. + http://bugzilla.maptools.org/show_bug.cgi?id=2315 + + * libtiff/libtiff.def: add some missing (64bit) APIs. + http://bugzilla.maptools.org/show_bug.cgi?id=2316 + +2011-04-09 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * libtiff 4.0.0beta7 released. + +2011-04-09 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * configure.ac: Should use AC_CANONICAL_HOST since host specifies + the run-time target whereas target is used to specify the final + output target if the package is a build tool (like a compiler), + which libtiff is not. Resolves libtiff bug 2307 "Use + AC_CANONICAL_HOST macro". + +2011-04-02 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * configure.ac: Support configuring TIFF_INT64_FORMAT and + TIFF_UINT64_FORMAT appropriately for MinGW32. + + * tools/tiffdump.c (ReadDirectory): MinGW32 needs to use WIN32 + printf conventions for 64-bit types because it uses the WIN32 CRT. + + * libtiff/{tif_dumpmode.c,tif_luv.c,tif_lzw.c,tif_print.c, + tif_read.c,tif_strip.c,tif_thunder.c}: MinGW32 needs to use WIN32 + printf conventions for 64-bit types because it uses the WIN32 CRT. + + * tools/tiff2pdf.c (t2p_write_pdf_string): Fix printf syntax not + understood by WIN32 CRT. + + * libtiff/tif_ojpeg.c: Fixes to compile with MinGW32 GCC. + + * tools/fax2ps.c (main): Use tmpfile() rather than mkstemp() since + it is much more portable. Tmpfile is included in ISO/IEC + 9899:1990 and the WIN32 CRT. + +2011-03-26 Frank Warmerdam <warmerdam@pobox.com> + + * tools/tiffset.c: add -d and -sd switches to allow operation on + a particular directory, not just the first (jef). + +2011-03-21 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_thunder.c: Correct potential buffer overflow with + thunder encoded files with wrong bitspersample set. The libtiff + development team would like to thank Marin Barbella and TippingPoint's + Zero Day Initiative for reporting this vulnerability (ZDI-CAN-1004, + CVE-2011-1167). + http://bugzilla.maptools.org/show_bug.cgi?id=2300 + +2011-03-10 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_fax3.h: Fix to last change allowing zero length + runs at the start of a scanline - needed for legal cases. + +2011-03-02 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_fax3.h: Protect against a fax VL(n) codeword commanding + a move left. Without this, a malicious input file can generate an + indefinitely large series of runs without a0 ever reaching the right + margin, thus overrunning our buffer of run lengths. Per CVE-2011-0192. + This is a modified version of a patch proposed by Drew Yao of Apple + Product Security. It adds an unexpected() report, and disallows the + equality case, since emitting a run without increasing a0 still allows + buffer overrun. + +2011-02-23 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_jpeg.c: avoid divide by zero in degenerate case (#2296) + + * tools/tiff2rgba.c: close source file on error to make leak + detection easier. + + * libtiff/tif_getimage.c: avoid leaks if TIFFRGBAImageBegin() fails. + + http://bugzilla.maptools.org/show_bug.cgi?id=2295 + +2011-02-22 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_lzma.c: Maintain tif_rawcc/tif_rawcp (CHUNKY_STRING_READ + _SUPPORT) + +2011-02-18 Frank Warmerdam <warmerdam@pobox.com> + + * configure.ac, configure: Added support for --enable-chunky-strip-read + configure option to enable the experimental feature from a couple + months ago for reading big strips in chunks. + + * configure.ac, tif_read.c, tif_readdir.c, tif_dir.h, tiffiop.h, + tif_write.c, tif_print.c, tif_jpeg.c, tif_dirwrite.c, tif_write.c: + Implement optional support for deferring the load of strip/tile + offset and size tags for optimized scanning of directories. Enabled + with the --enable-defer-strile-load configure option (DEFER_STRILE_LOAD + #define in tif_config.h). + +2011-02-11 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_print.c: remove unused variable. + +2011-02-09 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_win32.c: avoid error/warning buffer overrun problem + with non-console (popup message) builds on win32. + + http://bugzilla.maptools.org/show_bug.cgi?id=2293 + +2011-01-24 Olivier Paquet <olivier.paquet@gmail.com> + + * libtiff/{tif_dir.{h,c}, tif_dirinfo.c, tif_dirread.c, tif_dirwrite.c, + tif_print.c, tiff.h, tiffiop.h} : Added support for + TIFFTAG_SMINSAMPLEVALUE and TIFFTAG_SMAXSAMPLEVALUE to have different + values for each sample. Presents the min/max of all samples by default for + compatibility. TIFFSetField/TIFFGetField can be made to handle those tags + as arrays by changing the new TIFFTAG_PERSAMPLE pseudo tag. + http://www.asmail.be/msg0055458208.html + +2011-01-06 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_pixarlog.c: Note that tif_rawcc/tif_rawcp are not + maintained. + + * libtiff/tif_zip.c: Maintain tif_rawcc/tif_rawcp when decoding + for CHUNKY_STRIP_READ_SUPPORT. + + * libtiff/tif_jpeg.c: ensure that rawcc and rawcp are maintained + during JPEGPreDecode and JPEGDecode calls. + * libtiff/tif_read.c: larger read ahead for CHUNKY_STRIP_READ_SUPPORT, + as compression formats like JPEG keep 16 lines interleaved in a sense + and might need to touch quite a bit of data. + + http://trac.osgeo.org/gdal/ticket/3894 + +2011-01-03 Lee Howard <faxguy@howardsilvan.com> + + * libtiff/tif_jpeg.c: Fix regressions with 2 and 3 band images + caused by commit on 2010-12-14. Submitted by e-mail from + Even Rouault <even.rouault@mines-paris.org> + +2010-12-31 Olivier Paquet <olivier.paquet@gmail.com> + + * libtiff/tif_dirwrite.c: Fixed writing of TIFFTAG_REFERENCEBLACKWHITE. + http://bugzilla.maptools.org/show_bug.cgi?id=2266 + +2010-12-23 Andrey Kiselev <dron@ak4719.spb.edu> + + * tools/tiffcp.c, man/tiffcp.1: Added support for specifying the + compression level parameter (preset) for Deflate and LZMA encoders, + e.g "-c lzma:p1" or "-c zip:p9". + + * libtiff/tif_lzma.c: Properly set the LZMA2 compression level + (preset) in LZMAVSetField(). + +2010-12-18 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * libtiff/Makefile.am (libtiff_la_SOURCES): Added tif_lzma.c to + Makefile. + +2010-12-14 Andrey Kiselev <dron@ak4719.spb.edu> + + * configure.ac, libtiff/{tif_codec.c, tif_config.h.in, tiff.h, + tiffiop.h, tif_lzma.c}, tools/tiffcp.c, man/tiffcp.1: Implement a new + TIFF compression scheme LZMA reserving a new value 34925 for + Compression tag. As per + bug http://bugzilla.maptools.org/show_bug.cgi?id=2221 + +2010-12-14 Lee Howard <faxguy@howardsilvan.com> + + * libtiff/tif_dirread.c: tolerate some cases where + FIELD_COLORMAP is missing + http://bugzilla.maptools.org/show_bug.cgi?id=2189 + +2010-12-14 Lee Howard <faxguy@howardsilvan.com> + + * libtiff/tif_read.c: change read_ahead to tmsize_t + http://bugzilla.maptools.org/show_bug.cgi?id=2222 + +2010-12-14 Lee Howard <faxguy@howardsilvan.com> + + * configure.ac, libtiff/Makefile.am: Build tif_win32.c on + Windows except on Cygwin + http://bugzilla.maptools.org/show_bug.cgi?id=2224 + +2010-12-14 Lee Howard <faxguy@howardsilvan.com> + + * tools/gif2tiff.c: fix buffer overrun + http://bugzilla.maptools.org/show_bug.cgi?id=2270 + +2010-12-14 Lee Howard <faxguy@howardsilvan.com> + + * libtiff/tif_jpeg.c: reduce usage of JCS_UNKNOWN in order + to improve compatibility with various viewers + submitted by e-mail from Dwight Kelly <dkelly@apago.com> + +2010-12-13 Lee Howard <faxguy@howardsilvan.com> + + * tools/fax2ps.c: be consistent with page-numbering + http://bugzilla.maptools.org/show_bug.cgi?id=2225 + +2010-12-13 Lee Howard <faxguy@howardsilvan.com> + + * libtiff/tif_color.c: prevent crash in handling bad TIFFs + resolves CVE-2010-2595 + http://bugzilla.maptools.org/show_bug.cgi?id=2208 + +2010-12-13 Lee Howard <faxguy@howardsilvan.com> + + * tools/tiffcrop.c: new release by Richard Nolde + http://bugzilla.maptools.org/show_bug.cgi?id=2004 + +2010-12-12 Lee Howard <faxguy@howardsilvan.com> + + * tools/tiff2pdf.c: fix colors for images with RGBA + interleaved data + http://bugzilla.maptools.org/show_bug.cgi?id=2250 + +2010-12-12 Lee Howard <faxguy@howardsilvan.com> + + * libtiff/tif_dirread.c: fix for Zeiss LSM and Canon CR2 files + http://bugzilla.maptools.org/show_bug.cgi?id=2164 + +2010-12-11 Lee Howard <faxguy@howardsilvan.com> + + * tools/tiff2pdf.c: remove invalid duplication for Lab + http://bugzilla.maptools.org/show_bug.cgi?id=2162 + +2010-12-11 Lee Howard <faxguy@howardsilvan.com> + + * libtiff/tif_jpeg.c: fix use of clumplines calculation + http://bugzilla.maptools.org/show_bug.cgi?id=2149 + +2010-12-11 Lee Howard <faxguy@howardsilvan.com> + + * tools/fax2ps.c: replace unsafe tmpfile() with mkstemp() + http://bugzilla.maptools.org/show_bug.cgi?id=2118 + +2010-12-11 Lee Howard <faxguy@howardsilvan.com> + + * libtiff/tif_ojpeg.c, libtiff/tif_pixarlog.c, + libtiff/tif_zip.c: fix build errors for VC6 + http://bugzilla.maptools.org/show_bug.cgi?id=2105 + +2010-12-11 Lee Howard <faxguy@howardsilvan.com> + + * libtiff/tif_stream.cxx: warnings cleanup + http://bugzilla.maptools.org/show_bug.cgi?id=2091 + * libtiff/tif_dirread.c: warnings cleanup + http://bugzilla.maptools.org/show_bug.cgi?id=2092 + +2010-12-11 Lee Howard <faxguy@howardsilvan.com> + + * tools/tiff2pdf.c: add fill-page option + http://bugzilla.maptools.org/show_bug.cgi?id=2051 + +2010-12-11 Lee Howard <faxguy@howardsilvan.com> + + * libtiff/tif_dirread.c: modify warnings + http://bugzilla.maptools.org/show_bug.cgi?id=2016 + +2010-12-11 Lee Howard <faxguy@howardsilvan.com> + + * libtiff/tif_ojpeg.c: fix buffer overflow on problem data + http://bugzilla.maptools.org/show_bug.cgi?id=1999 + +2010-12-11 Lee Howard <faxguy@howardsilvan.com> + + * tools/tiffinfoce.c: strip byte counts are uint64* now + +2010-12-11 Lee Howard <faxguy@howardsilvan.com> + + * libtiff/tif_ojpeg.c: fix crash when reading a TIFF with a zero + or missing byte-count tag + * tools/tiffsplit.c: abort when reading a TIFF without a byte-count + per http://bugzilla.maptools.org/show_bug.cgi?id=1996 + +2010-12-08 Lee Howard <faxguy@howardsilvan.com> + + * libtiff/tif_dirread.c: fix crash when reading a badly-constructed + TIFF per http://bugzilla.maptools.org/show_bug.cgi?id=1994 + +2010-12-06 Lee Howard <faxguy@howardsilvan.com> + + * libtiff/tif_open.c: Fix mode check before opening a file. + http://bugzilla.maptools.org/show_bug.cgi?id=1906 + +2010-11-27 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * libtiff-4.pc.in: Added libtiff pkg-config .pc file support. + Patch by Vincent Torri. + +2010-10-21 Frank Warmerdam <warmerdam@pobox.com> + + * tools/tiffinfo.c: avoid direct reference to _TIFFerrorHandler. + + * libtiff/tif_config.vc.h: define snprintf to _snprintf for tiff2pdf. + + * libtiff/libtiff.def: export _TIFFCheckMalloc for tools. + +2010-09-25 Lee Howard <faxguy@howardsilvan.com> + + * tools/tiff2ps.c: improvements and enhancements from Richard Nolde + with additional command line options for Document Title, + Document Creator, and Page Orientation + +2010-07-13 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * tools/tiffcrop.c: Patch from Richard Nolde to avoid a + potentially unterminated buffer due to using an exceptionally long + file name. + +2010-07-08 Andrey Kiselev <dron@ak4719.spb.edu> + + * tools/tiff2pdf.c: Fixed ID buffer filling in + t2p_write_pdf_trailer(), thanks to Dmitry V. Levin. + +2010-07-07 Andrey Kiselev <dron@ak4719.spb.edu> + + * libtiff/tif_dirread.c: Really reset the tag count in CheckDirCount() + to expected value as the warning message suggests. As per bug + http://bugzilla.maptools.org/show_bug.cgi?id=1963 + +2010-07-06 Andrey Kiselev <dron@ak4719.spb.edu> + + * tools/tiffset.c: Properly handle TIFFTAG_PAGENUMBER, + TIFFTAG_HALFTONEHINTS, TIFFTAG_YCBCRSUBSAMPLING, TIFFTAG_DOTRANGE + which should be set by value. + + * libtiff/tif_dirinfo.c: Don't use assertions in _TIFFFieldWithTag() + and _TIFFFieldWithName() if the tag is not found in the tag table. + This should be normal situation and returned NULL value should be + properly handled by the caller. + +2010-07-02 Andrey Kiselev <dron@ak4719.spb.edu> + + * libtiff/tif_getimage.c: Avoid wrong math du to the signed/unsigned + integer type conversions. As per bug + http://bugzilla.maptools.org/show_bug.cgi?id=2207 + + * tools/{tiff2bw.c, thumbnail.c, pal2rgb.c}: Fix the count for + WhitePoint tag as per bug + http://bugzilla.maptools.org/show_bug.cgi?id=2042 + + * libtiff/tif_getimage.c: Check the number of samples per pixel when + working with YCbCr image in PickContigCase(). As per bug + http://bugzilla.maptools.org/show_bug.cgi?id=2216 + + * libtiff/tif_dir.c: Set the bogus post-decoding hook when processing + TIFFTAG_BITSPERSAMPLE in _TIFFVSetField() for the case of 8 bit when + we don't need any post-processing. That helps to reset the hook if we + previously set this field to some other value and the hook was + initialized accordingly. As per bug + http://bugzilla.maptools.org/show_bug.cgi?id=2035 + +2010-07-01 Andrey Kiselev <dron@ak4719.spb.edu> + + * tools/tiffgt.c: Properly check the raster buffer allocations for + integer overflows. As per bug + http://bugzilla.maptools.org/show_bug.cgi?id=2108 + + * m4/acinclude.m4: Update GL/GLU/GLUt/Pthread macros from the + upstream. + + * libtiff/{tif_aux.c, tif_strip.c, tif_tile.c, tiffiop.h}: Move + multiply_32() and multiply_64() functions into tif_aux.c file and + rename them into _TIFFMultiply32() and _TIFFMultiply64() respectively. + +2010-06-30 Andrey Kiselev <dron@ak4719.spb.edu> + + * tools/tiff2pdf.c: Better generation of ID field in + t2p_write_pdf_trailer(). Get rid of GCC aliasing warnings. + + * tools/tiff2pdf.c: Fixed computation of the tile buffer size when + converting JPEG encoded tiles. + + * tools/tiff2pdf.c: Better handling of string fields, use static + string buffers instead of dynamically allocated, use strncpy() instead + of strcpy(), control the string lengths. + +2010-06-25 Andrey Kiselev <dron@ak4719.spb.edu> + + * tools/tiffcp.c: Initialize buffer arrays with zero to avoid + referencing to uninitialized memory in some cases (e.g. when tile size + set bigger than the image size). + +2010-06-15 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * tools/tiffcrop.c: Patch from Richard Nolde. Reject YCbCr + subsampled data since tiffcrop currently doesn't support it. Fix + JPEG support. + +2010-06-13 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_dirinfo.c: Fix invocation of tag compare function (#2201) + + * tools/tiff2pdf.c: Fix assorted bugs in tiff2pdf: missing "return" + in t2p_read_tiff_size() causes t2p->tiff_datasize to be set entirely + wrong for COMPRESSION_JPEG case, resulting in memory stomp if actual + size is larger. Also, there are a bunch of places that try to + memset() a malloc'd buffer before checking for malloc failure, which + would result in core dump if there actually were a failure. (#2211) + +2010-06-11 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * libtiff/tiffiop.h (TIFFSafeMultiply): Need more castings to + avoid compiler warnings if parameter types are not sign + consistent. + + * libtiff 4.0.0alpha6 released. + + * tools/tiffcrop.c: Applied patch from Richard Nolde: Corrected + European page size dimensions. Added an option to allow the user + to specify a custom page size on the command line. Fix the case + where a page size specified with a fractional part was being + coerced to an integer by retyping the variables that define the + paper size. + + * html/index.html: Update for the 3.9.3 release. + + * tools/tiffcp.c (tiffcp): Applied Tom Lane's patch to reject + YCbCr subsampled data since tiffcp currently doesn't support it. + http://bugzilla.maptools.org/show_bug.cgi?id=2097 + + * Update libtool to version 2.2.10. + +2010-06-10 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * libtiff/tiffiop.h (TIFFSafeMultiply): Work properly if + multiplier is zero. + +2010-06-09 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * libtiff/tif_fax3.c (Fax3SetupState): Yesterday's fix for + CVE-2010-1411 was not complete. + + * libtiff/tiffiop.h (TIFFSafeMultiply): New macro to safely + multiply two integers. Returns zero if there is an integer + overflow. + + * tools/tiffcp.c (main): tiffcp should not leak memory if an error + is reported when reading the input file. + +2010-06-08 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * Update libtool to version 2.2.8. + + * libtiff/tif_fax3.c (Fax3SetupState): Avoid under-allocation of + buffer due to integer overflow in TIFFroundup() and several other + potential overflows. In conjunction with the fix to TIFFhowmany(), + fixes CVE-2010-1411. + + * libtiff/tiffiop.h (TIFFhowmany): Return zero if parameters would + result in an integer overflow. This causes TIFFroundup() to also + return zero if there would be an integer overflow. + + * contrib: Add an emacs formatting mode footer to all source files + so that emacs can be effectively used. + +2010-06-03 Oliver Chen Feng <scip8183@gmail.com> + + * libtiff/tools/tiffcp.c: add a new option -x to force merged tiff + file PAGENUMBER value in sequence for users who care the page + sequence, this will also prevent tiff2pdf from creating pdf file from + the merged tiff file with wrong page sequence. + +2010-05-08 Olivier Paquet <olivier.paquet@gmail.com> + + * libtiff/tif_dirread.c: Restored TIFFReadDirEntryFloat function in order + to add missing TIFF_SETGET_FLOAT case to TIFFFetchNormalTag. + * libtiff/tif_dirinfo.c: Use correct set_field_type for + TIFFTAG_PIXAR_FOVCOT so it is readable again (regression from 3.9.2). + http://bugzilla.maptools.org/show_bug.cgi?id=2192 + +2010-05-07 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_jpeg.c: Ensure that quality is always set in + JPEGPreEncode(), not just when we want to output local tables. + Otherwise the quality used during compression may not be right and + might not match the tables in the tables tag. This bug only occurs + when seeking between directories in the midst of writing blocks. + http://trac.osgeo.org/gdal/ticket/3539 + +2010-05-06 Andrey Kiselev <dron@ak4719.spb.edu> + + * html/man/TIFFGetField.3tiff.html, html/man/TIFFSetField.3tiff.html: + Regenerated from the source. + +2010-05-05 Olivier Paquet <olivier.paquet@gmail.com> + + * libtiff/tif_print.c: Fixed printing of TIFFTAG_REFERENCEBLACKWHITE which + had stopped working. Also made it always print 6 floats instead of + 2*SamplesPerPixel. + http://bugzilla.maptools.org/show_bug.cgi?id=2191 + http://bugzilla.maptools.org/show_bug.cgi?id=2186 + * man/TIFFGetField.3tiff, man/TIFFSetField.3tiff: Fixed doc to reflect the + fact that libtiff considers TIFFTAG_REFERENCEBLACKWHITE to be 6 floats. + +2010-05-05 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_jpeg.c: Fix to use memcmp(), not memcpy() when checking + if the jpeg table was written. This is a fix for the last fix on 04-21. + +2010-04-21 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_jpeg.c: avoid preparing jpeg tables everytime + JPEGSetupEncode() is called if the tables already seem to be + established. This prevents spurious updates and rewriting of + directories with jpegtables when doing updates to existing images. + http://trac.osgeo.org/gdal/ticket/3539 + +2010-04-20 Olivier Paquet <olivier.paquet@gmail.com> + + * libtiff/tif_dirinfo.c: Use correct set_field_type for + TIFFTAG_PIXAR_IMAGEFULLWIDTH, TIFFTAG_PIXAR_IMAGEFULLLENGTH, + TIFFTAG_PIXAR_MATRIX_WORLDTOSCREEN and TIFFTAG_PIXAR_MATRIX_WORLDTOCAMERA. + They were unreadable with TIFF_SETGET_UNDEFINED, a regression from 3.9.2. + http://bugzilla.maptools.org/show_bug.cgi?id=2139 + +2010-04-10 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * libtiff/tif_dir.c (_TIFFVSetField): Add a special error case for + when the tag count value is zero. Error handling is still a + regression since in 3.9.2, empty tags are skipped (with a warning) + rather than returning a hard error and refusing to read the file. + + * tools/ppm2tiff.c (main): While case for parsing comment line + requires extra parenthesis to work as expected. Reported by + Thomas Sinclair. + +2010-04-02 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_read.c (primarily): Add support for + CHUNKY_STRIP_READ_SUPPORT where large strips are + read in chunks for applications using TIFFReadScanline(). + This is intended to make it more practical work with very + large compressed one-strip files. Feature is off by default. + Enable by defining CHUNK_STRIP_READ_SUPPORT as a macro. + http://trac.osgeo.org/gdal/ticket/3514 + +2010-03-31 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_flush.c: Use TIFFRewriteDirectory() when flushing + directories so previously placed directories will be migrated to + the end of file if needed. + +2010-03-30 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_lzw.c: change type of dec_bitsleft field to uint64 + to support operating on strips/tiles of more than 256MB. + http://trac.osgeo.org/gdal/ticket/3512 + +2010-03-10 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * libtiff/tif_aux.c (_TIFFCheckRealloc): Improve error message so + that it is clearly a memory allocation error message, and also + includes the size of the allocation request. + +2010-02-22 Lee Howard <faxguy@howardsilvan.com> + + * libtiff/tif_jpeg.c: Do not generate a JPEGTables tag when creating + the JPEG TIFF as is is not required in order to prevent it from + being unused and filled with invalid data. (Leave it to be + generated by later activity.) + http://bugzilla.maptools.org/show_bug.cgi?id=2135 + * tools/tiff2pdf.c: Write the JPEG SOI headers into the TIFF strip + data rather than skipping them. This fixes the ability to view in + Acrobat Reader, Evince, and Ghostscript. + http://bugzilla.maptools.org/show_bug.cgi?id=2135 + * libtiff/tif_fax3.c: Don't return error on badly-terminated MMR + strips. + http://bugzilla.maptools.org/show_bug.cgi?id=2029 + +2009-12-03 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_jpeg.c: Made JPEGDecodeRaw() check for buffer overruns. + Made so that when working with downsampled images a stub function + reporting an error is used for tif_decoderow. We cannot meaningfully + support reading scanlines in this situation. (#1936) + + * libtiff/tif_jpeg.c: Ensure that tif_scanlinesize is computed after + resetting of the upsampling values (gdal:#3259). + http://bugzilla.maptools.org/show_bug.cgi?id=1936 + +2009-11-30 Frank Warmerdam <warmerdam@pobox.com> + + * contrib/dbs/tiff-grayscale.c, contrib/tif-palette.c, + tools/ras2tiff.c: Fix resource leaks on error. + http://bugzilla.maptools.org/show_bug.cgi?id=2121 + + * libtiff/tif_{aux.c,dir.c,dir.h,dirinfo.c}: Return to handling + TIFFTAG_REFERENCEBLACKWHITE as a field in the TIFF directory instead + of as a custom(generic) field to avoid a potential reentrancy problem. + http://bugzilla.maptools.org/show_bug.cgi?id=2125 + + * libtiff/tif_color.c, libtiff/tif_getimage.c, libtiff/tiffio.h, + man/TIFFcolor.3tiff: Make TIFFDisplay argument in TIFFCIELabToRGBInit + const, and display_sRGB static and const. + http://bugzilla.maptools.org/show_bug.cgi?id=2124 + 2009-11-04 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> - * libtiff 3.9.2 released. + * libtiff 4.0.0alpha5 released. 2009-11-03 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> @@ -10,13 +908,20 @@ 2009-11-02 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> - * port/libport.h: Added header file for porting prototypes and - extern declarations. + * port/libport.h: Add extern declarations for getopt standard + globals. 2009-10-31 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> - * libtiff/tif_dirwrite.c (TIFFWriteAnyArray): Add missing break - statement so writing an array of TIFF_DOUBLE works. + * libtiff/tif_lzw.c (LZWDecode, LZWDecodeCompat): Fix warnings + noticed in 64-bit build of libtiff with Visual Studio 2005. + Resolves "Bug 2067 - Visual Studio 2005 64-bit warnings in + tif_lzw.c", http://bugzilla.maptools.org/show_bug.cgi?id=2067 + + * libtiff/tif_pixarlog.c (PixarLogEncode): Fix non-important + warning noticed in Visual Studio 2005 build. Resolves "Bug 2068 - + Visual Studio 2005 64-bit warning in tif_pixarlog.c", + http://bugzilla.maptools.org/show_bug.cgi?id=2068 2009-10-29 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> @@ -46,36 +951,77 @@ "Bug 2090 - OJPEG crash with libjpeg v7". http://bugzilla.maptools.org/show_bug.cgi?id=2090 +2009-09-03 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_getimage.c: Fixed error recognition handling in RGBA + interface when stoponerror is set. + http://bugzilla.maptools.org/show_bug.cgi?id=2071 + 2009-08-30 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> - * contrib/iptcutil/iptcutil.c, - libtiff/tif_getimage.c,libtiff/tif_jpeg.c,libtiff/tif_ojpeg.c,tools/tiffcrop.c,tools/tiffgt.c: - Applied patch from Oden Eriksson to allow building with GCC using - the "-Wformat -Werror=format-security" flags. + * tools/{tiffcrop.c,tiffgt.c}: Applied patch from Oden Eriksson to + fix build with gcc when using the "-Wformat + -Werror=format-security" flags. -2009-08-28 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> +2009-08-29 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> - * libtiff 3.9.1 released. + * test/{bmp2tiff_palette.sh, bmp2tiff_rgb.sh, gif2tiff.sh, + ppm2tiff_pbm.sh, ppm2tiff_pgm.sh, ppm2tiff_ppm.sh}: Additional + utilities tests. -2009-08-28 Frank Warmerdam <warmerdam@pobox.com> +2009-08-28 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> - * libtiff/tif_dirwrite.c: Back out changes from 2007-11-22 that - resulted in the final strip not being written in some circumstances. - http://bugzilla.maptools.org/show_bug.cgi?id=2088 + * tools/tiffinfo.c: tiffinfo should return error status to the + caller. Register a private error callback to accomplish that. + + * test/Makefile.am (TIFFIMAGES): Add test images in BMP, GIF, and + PNM formats so that we will be able to test more of the tools. + While adding these test images I notice that bmp2tiff and gif2tiff + only support ancient versions of their respective formats. 2009-08-27 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> - * libtiff/tif_write.c (TIFFAppendToStrip): Remove cast which - caused libtiff to output a wrong last strip with byte-count and - strip-offset of zero. This cast was added on the day of the 3.9.0 - release. + * libtiff 4.0.0alpha4 released. + + * HOWTO-RELEASE: Improved release instructions. + +2009-08-24 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * man/{TIFFClose.3tiff,raw2tiff.1,tiffcmp.1,tiffsplit.1}: Applied + fixes for "Bug 2023 - nroff errors in manual pages". + http://bugzilla.maptools.org/show_bug.cgi?id=2023 + + * tools/{rgb2ycbcr.c, tiff2rgba.c}: Applied fixes for "Bug 2079 - + CVE-2009-2347 libtiff: integer overflows in various inter-color + space conversion tools". + http://bugzilla.maptools.org/show_bug.cgi?id=2079 + + * libtiff/tif_print.c (TIFFPrintDirectory): Apply fix from Jay + Berkenbilt for "Bug 2024 - possible null pointer dereference with + one-line fix". + http://bugzilla.maptools.org/show_bug.cgi?id=2024 - * libtiff/tif_config.vc.h: tiffiop.h needs the TIFF_INT64_T and - TIFF_UINT64_T defines in order to compile. Copy existing - definitions from tiffconf.vc.h. + * libtiff/tif_dirread.c (TIFFReadCustomDirectory): Apply patch + from Jay Berkenbilt for "Bug 1895 - logic error in tif_dirread.c: + segfault after setting tdir_tag = IGNORE". + http://bugzilla.maptools.org/show_bug.cgi?id=1895 + +2009-08-23 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * test/Makefile.am, test/tiffcrop*.sh: Split previously existing + tiffcrop.sh into a collection of many specific tests. Re-wrote + all of the existing tests to be based on some simple shell + functions. Make distcheck works again. + + Export certain variables (MAKE, MAKEFLAGS, MEMCHECK) to tests and + added 'memcheck' and 'ptrcheck' targets to make it easy to run the + tests under valgrind. 2009-08-21 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + * test/tiffcp-logluv.sh: Fix test so that it works with a VPATH + build. + * test/Makefile.am (AUTOMAKE_OPTIONS): Colorized tests was not actually activated since it needed to be enabled in this Makefile.am. Also activated parallel-tests mode since it offers @@ -84,55 +1030,148 @@ 2009-08-20 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> - * libtiff 3.9.0 released. - - * libtiff/tif_print.c (TIFFPrintDirectory): Applied patch for "tag - error may cause segfault in tif_print.c." - http://bugzilla.maptools.org/show_bug.cgi?id=1896 - - * tools/{rgb2ycbcr.c, tiff2rgba.c}: Applied patch for - CVE-2009-2347 libtiff: integer overflows in various inter-color - space conversion tools. - http://bugzilla.maptools.org/show_bug.cgi?id=2079 - * configure.ac: Updated autotools. Autoconf 2.64, Automake 1.11, libtool 2.2.6. Enabled support for silent build rules (--enable-silent-rules or 'make V=0') and colorized tests. + * html/{index.html, v3.9.0.html}: Update for 3.9.0 release. + 2009-06-30 Frank Warmerdam <warmerdam@pobox.com> + * tests/tiffcp-logluv.sh: minimal testing of sgilog compression. + + * tools/tiffcp.c: add -c sgilog support. + * libtiff/tif_luv.c: correct return codes from encoderow to be 1 on success instead of zero. http://bugzilla.maptools.org/show_bug.cgi?id=2069 + * libtiff/tif_lzw.c: back out patch from #2065 and apply patch from + #1085 for a better underflow fix that errors properly. + http://bugzilla.maptools.org/show_bug.cgi?id=2065 + http://bugzilla.maptools.org/show_bug.cgi?id=1985 + +2009-06-26 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_strip.c: Remove an inappropriate assertion that often + fails on oddly sized 12bit jpeg compressed ycbcr images. + 2009-06-22 Frank Warmerdam <warmerdam@pobox.com> * libtiff/tif_lzw.c: Fix buffer underflow bug. http://bugzilla.maptools.org/show_bug.cgi?id=2065 +2009-06-21 Frank Warmerdam <warmerdam@pobox.com> + + * configure.ac, libtiff/tif_jpeg.c, libtiff/tif_jpeg_12.c: add support + for dual mode 8/12 bit jpeg support. + 2009-06-03 Frank Warmerdam <warmerdam@pobox.com> * libtiff/tif_write.c: do not override the planar configuration to be contig for one sample files if planar configuration is already set. http://bugzilla.maptools.org/show_bug.cgi?id=2057 +2009-06-02 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/libtiff.def: Add TIFFUnsetField. + +2009-05-03 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/{tif_jpeg.c,tif_ojpeg.c,tif_getimage.c}: Fixed various + error reports to use "%s" as format string. + http://trac.osgeo.org/gdal/ticket/2976 + +2009-03-12 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/{tif_fax3.c,tif_jpeg.c,tif_ojpeg.c}: Fix printdir chaining + for some codecs (#2020). + 2009-02-12 Frank Warmerdam <warmerdam@pobox.com> * libtiff/tif_luv.c: Fix handling of tiled logluv images. http://bugzilla.maptools.org/show_bug.cgi?id=2005 +2009-02-09 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_dirread.c: Improve allocation safety when allocated + buffer for large tags. (#1998) Related to (#1993) + +2009-02-06 Frank Warmerdam <warmerdam@pobox.com> + + * tools/tiffcrop.c: Don't default image->res_unit to INCH. Now the + test suite should pass. + +2009-02-05 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_dirread.c: Re-incorporated a sanity check on tag size, + but at the 2GB boundary to avoid overflow on 32bit systems. + http://bugzilla.maptools.org/show_bug.cgi?id=1993 + + * libtiff/tif_dirread.c: Remove some assertions that blow due to + corrupt files rather than in response to library internal + inconsistencies. + http://bugzilla.maptools.org/show_bug.cgi?id=1995 + http://bugzilla.maptools.org/show_bug.cgi?id=1991 + + * libtiff/tif_dirread.c: Fixed testing for failed result from + TIFFReadDirectoryFindFieldInfo(). + http://bugzilla.maptools.org/show_bug.cgi?id=1992 + 2009-01-23 Frank Warmerdam <warmerdam@pobox.com> * libtiff/tif_predict.c: Add support for 32bit integer horz. predictors. http://bugzilla.maptools.org/show_bug.cgi?id=1911 + * libtiff/tif_dirwrite.c: Fix byte swapping of next directory offset. + + http://bugzilla.maptools.org/show_bug.cgi?id=1924 + + * tools/tiffcrop.c: initialize xres/yres values. + + * test/*.sh - default ${srcdir} to local directory. + + * test/common.sh - start verbose mode after common settings. + + * libtiff/tif_dirinfo.c: Replace lfind() with local equivelent to + avoid type mismatches on different platforms. + http://bugzilla.maptools.org/show_bug.cgi?id=1889 + +2009-01-22 Frank Warmerdam <warmerdam@pobox.com> + + * tools/{fax2tiff.c,thumbnail.c,tiff2pdf.c,tiff2ps.c,tiffdump.c, + tiffsplit.c}: avoid warnings, mostly 32bit/64bit casting issues. + + * port,tools: Introduce libport.h, and include in tools if NEED_LIBPORT + defined, primarily to reduce prototype warnings on windows. + + * libtiff/tif_dirinfo.c,tif_dirread.c: Avoid warnings + about unused parameters, and uninitialized variables. + +2009-01-21 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * test/common.sh: Execute tests like 'make VERBOSE=TRUE check' in + order to trace full execution detail while executing the test suite. + 2009-01-20 Frank Warmerdam <warmerdam@pobox.com> * tools/tiffsplit.c: fix sampleformat to be shortv instead of longv. +2009-01-20 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * test/Makefile.am (CLEANFILES): Make sure that test output files + are removed by 'make clean' + + * Update autotools for 4.0.0 beta3 + + * 4.0.0 beta3 produced. + 2009-01-12 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> - * tools/tiff2ps.c: Remove spurious message printed to stderr. + * test/tiffcrop.sh: New test script for tiffcrop from Richard + Nolde. + + * tools/tiff2ps.c: Remove spurious message to stderr. 2009-01-11 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> @@ -140,62 +1179,77 @@ from Richard Nolde. In particular, support for rotating the image by 90, 180, 270, and 'auto' has been added. + * man/tiffcrop.1: Incorporated documentation updates from Richard + Nolde. + * tools/tiffcrop.c: Incorporated significant functionality update from Richard Nolde. -2009-01-06 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> +2008-12-31 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> - * libtiff/tiffiop.h: Add private type declarations for int64, and - uint64 so that bundled utilities (like tiffcrop) can use it when - necessary. + * libtiff/tiffio.h: GCC will now validate format specifications + for TIFFError(), TIFFErrorExt(), TIFFWarning(), and + TIFFWarningExt() in order to reveal bugs. -2009-01-01 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + * Many fixes throughout to work better as a 64-bit build. - * configure.ac: Updated to test for 64-bit types. This version of - the library does not require a 64-bit type, but tiffcrop needs it. +2008-12-30 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> -2008-12-31 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + * tools/{tiff2pdf.c, tiff2ps.c, tiffinfo.c}: Offset and length + tags now require 64-bit parameter rather than 32-bit. - * Update to use current FSF autotools versions. - * libtiff/tiffio.h: GCC will now validate format specifications - for TIFFError(), TIFFErrorExt(), TIFFWarning(), and - TIFFWarningExt() in order to reveal bugs. Cleaned up resulting - warnings throughout for 32 bit build only. + * libtiff/tif_dirread.c: Fixed issues with unaligned access to + 64-bit values. -2008-12-31 Frank Warmerdam <warmerdam@pobox.com> + * tools/thumbnail.c: Eliminate crash noticed while running test + suite. - * tools/tiffcrop.c, man/tiffcrop.1: A major update from Richard - Nolde. +2008-12-29 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> -2008-12-21 Frank Warmerdam <warmerdam@pobox.com> + * libtiff/tif_ojpeg.c (OJPEGLibjpegJpegSourceMgrFillInputBuffer): + Initialize stack variables to avoid compiler warning. - * libtiff/tif_jpeg.c: Avoid errors if the application writes a full - strip for the last partial strip in a jpeg compressed file. - http://bugzilla.maptools.org/show_bug.cgi?id=1981 + * tools/tiffinfoce.c (main): Use toff_t for offset type when + retrieving offset of EXIF IFD. + + * libtiff/tiffio.h: Undeprecate toff_t and restore its use in the + TIFFClientOpen() callback and other external function definitions. + + * tools/tiffinfo.c (main): Offset to EXIF IFD requires a 64-bit + type now. Fixes crash when dumping files containing an EXIF IFD. + + * m4/libtool.m4: Update to libtool 2.2.6. 2008-12-21 Frank Warmerdam <warmerdam@pobox.com> - * libtiff/tif_getimage.c, tiffio.h: More ABI corrections. - Removed SubsamplingHor/Ver from TIFFRGBAImage structure. - http://bugzilla.maptools.org/show_bug.cgi?id=1980 + * libtiff/tif_dir.c, tiffio.h: Introduce TIFFUnsetField() function. -2008-12-18 Frank Warmerdam <warmerdam@pobox.com> + * libtiff/tif_jpeg.c: Avoid errors if the application writes a full + strip for the last partial strip in a jpeg compressed file. + http://bugzilla.maptools.org/show_bug.cgi?id=1981 - * libtiff/tif_getimage.c,tiffio.h: removed all use of UaToAa and - Bitmap16to8 arrays in TIFFRGBAImage structure to restore ABI - compatability. These were just an attempt to speed up processing - with precalculated tables. - http://bugzilla.maptools.org/show_bug.cgi?id=1979 +2008-10-29 Frank Warmerdam <warmerdam@pobox.com> - * libtiff/tif_codec.c: Avoid printing c->name if it does not exist. + * libtiff/tif_flush.c: Make sure that BEENWRITING is cleared when + we take the shortcut to only update the strip/tile offsets in place. + http://trac.osgeo.org/gdal/ticket/2621 2008-10-21 Andrey Kiselev <dron@ak4719.spb.edu> * libtiff/tif_jbig.c: Support the JBIG-KIT 2.0 (compatibility with the older versions retained). +2008-10-09 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_jpeg.c: Add #ifdefs for changes needed if using + IPP enabled version of libjpeg from Intel. + http://bugzilla.maptools.org/show_bug.cgi?id=1951 + 2008-09-05 Andrey Kiselev <dron@ak4719.spb.edu> + * tools/tiffsplit.c: Use byte counts of proper size (uint64). + Required for libtiff 4.0. + * tools/tiffsplit.c: Use dynamically allocated array instead of static when constructing output file names. @@ -214,35 +1268,225 @@ * libtiff/tif_lzw.c: Properly zero out the string table. Fixes CVE-2008-2327 security issue. +2008-09-01 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_dirread.c: Avoid unused TIFFReadDirEntryFloat() function. + + * libtiff/tif_dirwrite.c: modified to write IFDs as either IFD8 or IFD + depending on whether the file is bigtiff or classic tiff. + http://bugzilla.maptools.org/show_bug.cgi?id=1917 + +2008-08-12 Edward Lam <edward@sidefx.com> + + * tools/tiffdump.c: When compiling for Microsoft Windows, apply + consistent (__int64) casting when testing if _lseeki64 has + successfully seeked as requested. This is necessary for large + file support to work since off_t is only 32-bit. + +2008-07-29 Frank Warmerdam <warmerdam@pobox.com> + + * tif_strip.c: Replace assertions related to samplesperpixel != 3 or + the subsampling values not being 1, 2 or 4 (for jpeg compressed images) + with control logic to return runtime errors (c/o Even Rouault) (#1927). + +2008-06-17 Frank Warmerdam <warmerdam@pobox.com> + + * tools/tiffcrop.c: Fix some portability problems. + + * libtiff/tif_ojpeg.c: Use same jpeg/win32 boolean/FAR hacks as are + used in tif_jpeg.c. + + * libtiff/tif_win32.c: Ensure TIFFOpenW() uses same FILE_SHARE flags + as TIFFOpen(). + +2008-06-01 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_dirwrite.c: Fix alignment problems affecting architectures + like Sparc/Solaris. + http://bugzilla.maptools.org/show_bug.cgi?id=1892 + +2008-05-27 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff.def: Add TIFFFindField + http://bugzilla.maptools.org/show_bug.cgi?id=1891 + +2008-05-26 Frank Warmerdam <warmerdam@pobox.com> + + * tif_config.*.h, tiffconf.*.h: Remove SIZEOF_LONG definition, unused. + + * li2008-04-15 Andrey Kiselev <dron@ak4719.spb.edu> + +btiff/tif_win32.c: Replace custom Win32 memory api with generic + POSIX one. No apparent value to use of GlobalAlloc() in the modern + age. http://bugzilla.maptools.org/show_bug.cgi?id=1885 + + * libtiff/tiffconf.vc.h: Added JBIG_SUPPORT and MDI_SUPPORT items + in windows version (care of Edward Lam). + 2008-05-24 Frank Warmerdam <warmerdam@pobox.com> * tif_codec.c: Avoid NULL pointer dereferencing for exotic compression codec codes. - * tif_dirread.c: zero tif->tif_dir after freeing the directory - in TIFFReadCustomDirectory(). I don't exactly remember why this - was important. - - * tif_dirwrite.c: Fix potential memory leak writing large double - tags. + * tif_dirwrite.c: fix potential memory leak. * tif_dirread.c: Fix unchecked malloc result. + +2008-05-24 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * test {tiff2pdf.sh tiff2ps-EPS1.sh tiff2ps-PS1.sh tiff2ps-PS2.sh + tiff2ps-PS3.sh tiffcp-g3-1d-fill.sh tiffcp-g3-1d.sh + tiffcp-g3-2d-fill.sh tiffcp-g3-2d.sh tiffcp-g3.sh tiffcp-g4.sh + tiffcp-split-join.sh tiffcp-split.sh tiffcp-thumbnail.sh + tiffdump.sh tiffinfo.sh}: Added more test scripts based on + suggestions from Lee Howard posted to the tiff list on 13 Sep + 2007. + +2008-05-23 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_fax3.c: Add an assert in an effort to detect a + possible runtime problem reported by coverity. + + * contrib/iptcutil/iptcutil.c: Fixed memory leak of str. + + * tools/tiffcrop.c, man/tiffcrop.1: Major update from Richard Nolde. + http://bugzilla.maptools.org/show_bug.cgi?id=1888 + + * tools/tiffdither.c: remove dead onestrip code. avoid memory leak. + + * tools/rgb2ycbcr.c: fix memory leak of raster buffer. + + * tools/tiffcp.c: Simplify inknames code to avoid pointless test. + Cleanup scanline allocation to avoid coverity warning. + + * tools/thumbnail.c: Check for TIFFOpen() failure. + +2008-05-18 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_dirinfo.c: Use TIFF_SETGET_ASCII for PIXAR_TEXTUREFORMAT + and PIXAR_WRAPMODES instead of TIFF_SETGET_UNDEFINED. Not exactly clear + why this is needed. + +2008-05-09 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * Makefile.am (ACLOCAL_AMFLAGS): Libtool 2.2.4 does not like + "ACLOCAL_AMFLAGS=-I ./m4". It wants "ACLOCAL_AMFLAGS=-I m4". + +2008-04-15 Andrey Kiselev <dron@ak4719.spb.edu> + + * test/: Test suite updated. Everything is passed now. + + * libtiff/tif_dirinfo.c: Fixed description of the + TIFFTAG_NUMBEROFINKS tag. + +2008-04-14 Andrey Kiselev <dron@ak4719.spb.edu> + + * libtiff/{tif_dirread.c, tif_dirwrite.c, tiffiop.h}: + Get rid of some of "dereferencing type-punned" warnings by converting + tdir_offset field of TIFFDirEntry structure into union. + +2008-04-10 Andrey Kiselev <dron@ak4719.spb.edu> + + * libtiff/{tif_flush.c, tif_dirwrite.c, tiffio.h, tiffiop.h}: + TIFFRewriteField() renamed into _TIFFRewriteField() and moved out + from the public interface. Type of its 'count' parameter changed + from uint32 to tmsize_t. + + * /libtiff/tiffiop.h: Make tif_nfields and tif_nfieldscompat fields + of the tiff structure have the size_t type instead of uint32. + +2008-04-09 Andrey Kiselev <dron@ak4719.spb.edu> + + * tools/tiffdump.c: Added support for MSVS 6.0. + + * libtiff/tif_dirread.c: Use custom functions _TIFFUInt64ToFloat() + and _TIFFUInt64ToDouble() to convert 64-bit integers into floating + point values on MSVS 6.0 platform. + +2008-03-14 Frank Warmerdam <warmerdam@pobox.com> + + * tif_dirread.c: Removed sanity checks on tags larger than 4MB in + TIFFReadDirEntryArray() since they are interfering with seemingly + legitimate files. http://trac.osgeo.org/gdal/ticket/2005 + +2008-02-09 Joris Van Damme <joris.at.lebbeke@skynet.be> + + * tif_dirread.c: Added handling for the case of number of values for + PageNumber tag different from 2 (previously resulted in an assert + indicating lack of handling and was forgotten about) + +2008-02-01 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_jpeg.c: Do not try to fixup subsampling tags based on + the actual jpeg data stream if the first strip/tile has zero size. + This is the case when GDAL creates a new file with zero sizes, closes + and reopens it. + +2008-01-07 Frank Warmerdam <warmerdam@pobox.com> + + * tools/tiff2ps.c: fix up 64bit issues (from Edward Lam). + +2008-01-01 Frank Warmerdam <warmerdam@pobox.com> + + * libtiff/tif_dirwrite.c: #ifdef out lots of unused functions. + + * Makefile.vc, libtiff/Makefile.vc, tools/Makefile.vc: Improve clean + targets. + + * tools/tiffinfo.c, tools/tiffcmp.c, tools/gif2tiff.c, tools/bmp2tiff.c + tools/tiff2pdf.c: Fix 64-bit warnings when compiling under MSVC 2005 + (x64). + + * tools/tiffset.c: Changes to reflect the fact that TIFFFieldWithTag() + and TIFFFieldWithName() now return TIFFField pointers instead of + TIFFFieldInfo pointers. + + * tools/tiffdump.c: Added ssize_t typedef on Windows since it doesn't + exist. This makes it compile again on Windows + + * tif_aux.c, tif_getimage.c, tif_next.c, tif_predict.c, tif_win32.c, + tiffconf.vc.h: Various 64bit fixes from Edward Lam identified on win64. + + * test/rewrite_tag.c: New test for TIFFRewriteField(). + +2007-12-31 Frank Warmerdam <warmerdam@pobox.com> + + * tif_dirwrite.c: Added TIFFRewriteField(). This new function + rewrites one field "on disk" updating an existing directory + entry. Lots of limitations still... + + * tiffiop.h, tif_write.c, tif_dirread.c, tif_flush.c: Keep track of + TIFF_DIRTYSTRIP separately from TIFF_DIRTYDIRECT to indicate that + the strip offset/size values are dirty but nothing else about the + directory is dirty. In flush handle "just stripmaps dirty" as a + special case that just rewrites these values without otherwise + modifying the directory on disk using TIFFRewriteField(). -2008-01-30 Andrey Kiselev <dron@ak4719.spb.edu> + We also modify logic so that in update mode the directory is not + marked dirty on read, but only when something is changed. This + means we need to keep track of updates to the stripmap stuff in + TIFFAppendToStrip(). - * tif_fax3.c: Make find0span() and find1span() non-inline to - make MSVC 6.0 compiler happy. +2007-12-10 Frank Warmerdam <warmerdam@pobox.com> -2007-11-26 Frank Warmerdam <warmerdam@pobox.com> + * tif_jpeg.c: Improve ability to switch between encoding and decoding + in the jpeg code (gdal bug #2033). - * tif_fax3.c: fix leak of FAXCS state (per bug 1603). +2007-11-23 Frank Warmerdam <warmerdam@pobox.com> + + * tif_dir.c, tif_dirread.c, tif_dirwrite.c, tif_read.c, tif_write.c, + tiffiop.h: Added TIFF_BUF4WRITE flag to indicate if contents of the + rawcp/rawcc buffer are for writing and thus may require flushing. + Necessary to distinguish whether they need to be written to disk when + in mixed read/write mode and doing a mixture of writing followed by + reading. http://trac.osgeo.org/gdal/ticket/1758 2007-11-23 Andrey Kiselev <dron@ak4719.spb.edu> * configure.com, libtiff/tif_vms.c: Better OpenVMS support. Patches from Alexey Chupahin. -2007-11-22 Frank Warmerdam <warmerdam@pobox.com> +2007-11-02 Frank Warmerdam <warmerdam@pobox.com> * tif_write.c: Rip out the fancy logic in TIFFAppendToStrip() for establishing if an existing tile can be rewritten to the same location @@ -265,31 +1509,150 @@ modifying callers buffer. http://trac.osgeo.org/gdal/ticket/1965 + * tif_predict.c/h: more fixes related to last item, keeping a + distinct pfunc for encode and decode cases as these were getting + mixed up sometimes. + http://trac.osgeo.org/gdal/ticket/1948 + +2007-11-01 Frank Warmerdam <warmerdam@pobox.com> + * tif_predict.c/h, tif_lzw.c, tif_zip.c: Improvements so that predictor based encoding and decoding works in read-write update mode properly. http://trac.osgeo.org/gdal/ticket/1948 +2007-10-24 Joris Van Damme <joris.at.lebbeke@skynet.be> + + * tif_dirread.c: Fixed problem with bogus file triggering + assert(td->td_planarconfig == PLANARCONFIG_CONTIG) in + ChopUpSingleUncompressedStrip + +2007-10-22 Joris Van Damme <joris.at.lebbeke@skynet.be> + + * tif_jpeg.c: Resolved buffer incrementation bug that lead to faulty images + at best, access violation at worst, when subsampled JPEG compressed imagery + is decoded without the JPEG_COLORMODE feature + +2007-10-11 Frank Warmerdam <warmerdam@pobox.com> + + * html/index.html: Update "people responsible" section. + 2007-10-05 Frank Warmerdam <warmerdam@pobox.com> - * tools/tiff2pdf.c: Fixed setting of alpha value per report on list. + * tools/tiff2pdf.c: Fix problem with alpha setting in some cases + as reported on the mailing list. + +2007-10-01 Joris Van Damme <joris.at.lebbeke@skynet.be> + + * changed some more incorrect %lud printf flags to %lu + +2007-09-29 Joris Van Damme <joris.at.lebbeke@skynet.be> + + * tif_dirread.c: Strip chopping interfered badly with uncompressed + subsampled images because it tried to divide subsampled rowblocks, + leading to all sorts of errors throughout the library for these + images. Fixed by making strip chopping divide in row counts that + are a multiple of vertical subsampling value. + +2007-09-28 Joris Van Damme <joris.at.lebbeke@skynet.be> + + * tif_dirread.c: Logical cast working around compiler warning -2007-09-13 Frank Warmerdam <warmerdam@pobox.com> + * tif_read.c: Correction of some error flags and parameter lists + +2007-09-27 Joris Van Damme <joris.at.lebbeke@skynet.be> + + * tif_dirread.c: Made calculation of td_maxsamplevalue more robust + when dealing with large bitspersample values, shutting up purification + tools that warn about truncation, though it remains incorrect and + indicates a conceptual problem there. + + * tif_open.c: Moved early exit in case of 'h' flag (to disable reading + of first IFD) to proper place because it badly interfered with memory + mapping, resulting in mapping flag even with dummy mapping functions + that returned 0 whilst at the same time the mapping tif_size wasn't + set, thus resulting in continuous incorrect beyond-eof errors. + +2007-09-24 Joris Van Damme <joris.at.lebbeke@skynet.be> + + * tif_dirinfo.c: Fixed (MSVC) compiler reports about + inconsistent use of const in tiffFields and exifFields definition + +2007-09-20 Frank Warmerdam <warmerdam@pobox.com> + + * tif_dirwrite.c: Always write tile/strip offsets and sizes + using LONG8 type when output format is BigTIFF. The + TIFFWriteDirectoryTagLongLong8Array() function was restructured + accordingly. + + * tif_dirread.c: Improvements to error reporting text in + TIFFFetchDirectory(). + +2007-09-19 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * test/images: Added a small collection of test images for use by + test programs and scripts. + * test/tiffinfo.sh: A trivial example test script. + * test/common.sh: Added small script for setting the environment + used by script-based tests. + +2007-08-24 Frank Warmerdam <warmerdam@pobox.com> + + * tif_dirwrite.c: Write the tif_nextdiroff value instead of a fixed + zero when writing directory contents to preserve the ability to + rewrite directories in place, even in the middle of a directory + chain. * tif_dirinfo.c: _TIFFMergeFields() now only merges in field definitions that are missing. Existing definitions are silently - ignored. (Bug #1585) + ignored. + + * tif_dirread.c: Add runtime error for fields for which no definition + is found (in addition to an assert for developers) in + TIFFFetchNormalTag(). Not sure if this is needed, but it seems + prudent. + +2007-08-10 Joris Van Damme <joris.at.lebbeke@skynet.be> + + * libtiff/tif_getimage.c: removed SubsamplingHor and SubsamplingVer + from _TIFFRGBAImage structure to revert unwanted ABI change. + +2007-08-10 Joris Van Damme <joris.at.lebbeke@skynet.be> + + * libtiff/tif_win32.c: use SetFilePointer instead of + SetFilePointerEx, as per bug + + http://bugzilla.remotesensing.org/show_bug.cgi?id=1580 + +2007-07-19 Andrey Kiselev <dron@ak4719.spb.edu> + + * libtiff/tif_stream.cxx: Put all callback functions declarations + inside extern "C" block. + + * libtiff/{tif_lzw.c, tif_luv.c, tif_dumpmode.c, tif_print.c, + tif_read.c, tif_strip.c, tif_thunder.c}: Use "%I64d" printf() + formatter instead of "%lld" with MSVC compiler. + + * libtiff/{tiffiop.h, tif_aux.c}: Added _TIFFUInt64ToFloat() and + _TIFFUInt64ToDouble() functions. 2007-07-18 Andrey Kiselev <dron@ak4719.spb.edu> + * libtiff/tif_dirread.c: Handle the case of MSVC 6 when using 64-bit + integer constants. + * libtiff/{Makefile.am, Makefile.v}: Do not distribute tiffconf.h, remove tif_config.h/tiffconf.h during cleaning. As per bug http://bugzilla.remotesensing.org/show_bug.cgi?id=1573 + * libtiff/tif_unix.c: Do not use O_LARGEFILE. As per bug + + http://bugzilla.remotesensing.org/show_bug.cgi?id=1577 + 2007-07-13 Andrey Kiselev <dron@ak4719.spb.edu> - * libtiff 3.9.0beta released. + * libtiff 4.0.0alpha released. 2007-07-12 Andrey Kiselev <dron@ak4719.spb.edu> @@ -297,8 +1660,56 @@ http://bugzilla.remotesensing.org/show_bug.cgi?id=1567 + * libtiff/{tif_close.c, tif_dirinfo.c, tiffiop.c, tif_dirread.c, + tif_dir.h, tif_dir.c, tiffio.h}: Transition to the new-style tag + extending scheme completed. + +2007-07-11 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * libtiff/tif_stream.cxx: Adapt to use toff_t again. Update to + use standard C++ library size types and attempt to detect overflow + cases. + +2007-07-08 Andrey Kiselev <dron@ak4719.spb.edu> + + * libtiff/{tif_jpeg.c, tif_dir.h, tif_dir.c, tif_dirinfo.c, tiffio.h, + tif_ojpeg.c, tif_print.c, tif_fax3.c, tif_dirread.c}: More work on new + tag extending scheme. Use the new scheme everywhere. + + * libtiff/{tif_zip.c, tif_predict.c, tif_pixarlog.c, tif_luv.c, + tif_fax3.c, tif_dirread.c, tif_dirwrite.c, tif_close.c, tif_ojpeg.c, + tif_jpeg.c, tif_dirinfo.c, tif_dir.h, tiffio.h, tiffiop.h}: + TIFFFIeldInfo structure replaced with TIFFField structure. + TIFFFieldInfo retained for the backward compatibility. + +2007-07-05 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> + + * tools/tiff2pdf.c: Fix a compile problem when JPEG_SUPPORT is not + defined. + +2007-07-04 Andrey Kiselev <dron@ak4719.spb.edu> + + * libtiff/{tif_dir.c, tiff.h, tiffio.h, libtiff.def}: Unused + TIFFReassignTagToIgnore() function and TIFFIgnoreSense enumeration + removed. + + * libtiff/{tif_dirinfo.c, tif_fax3.c, tif_jbig.c, tif_jpeg.c}: Move + tags TIFFTAG_FAXRECVPARAMS, TIFFTAG_FAXSUBADDRESS, + TIFFTAG_FAXRECVTIME and TIFFTAG_FAXDCS to the common tag directory. + These tags are not codec-specific and relate to image content, so + process them as other normal tags. + + * libtiff/{tiffio.h, tif_dir.h}: TIFFTagValue structure moved from the + public tiffio.h to private tif_dir.h. + + * contrib/{acorn, mac-cw, mac-mpw}: Removed as unmaintained and + outdated. + 2007-07-03 Andrey Kiselev <dron@ak4719.spb.edu> + * libtiff{tif_acorn.c, tif_apple.c, tif_atari.c, tif_msdos.c, + tif_win3.c}: Obsoleted portability stuff removed. + * tools/tiff2ps.c: Added support 16-bit images as per bug http://bugzilla.remotesensing.org/show_bug.cgi?id=1566 @@ -314,23 +1725,22 @@ PDF file using TIFFClientOpen() machinery as it is implemented by Leon Bottou. -2007-06-29 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> +2007-06-26 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> - * libtiff/tif_dirinfo.c (_TIFFFindFieldInfo): Don't attempt to - bsearch() on a NULL fieldinfo list. - (_TIFFFindFieldInfoByName): Don't attempt to - lfind() on a NULL fieldinfo list. + * configure.ac: Fix typo when substituting value for unsigned 8 bit type. + Added support for a TIFF_PTRDIFF_T type to use when doing pointer arithmetic. + Added support for a TIFF_SSIZE_T in order to return memory sizes but still + allow returning -1 for errors. + * libtiff/tiffconf.vc.h: Add porting type defintions for WIN32. -2007-05-01 Andrey Kiselev <dron@ak4719.spb.edu> +2007-06-25 Bob Friesenhahn <bfriesen@simple.dallas.tx.us> - * libtiff/tif_dirwrite.c: Fixed problem introduced with a fix for a - byte swapping issue - - http://bugzilla.remotesensing.org/show_bug.cgi?id=1363 - - As per bug - - http://bugzilla.remotesensing.org/show_bug.cgi?id=1550 + * port/strtoull.c: New porting function in case strtoull() is not + available on the target system. + * configure.ac: Add configure support for determining sized types + in a portable way and performing necessary substitutions in + tif_config.h and tiffconf.h. Updated tiff.h to use the new + definitions. 2007-04-27 Andrey Kiselev <dron@ak4719.spb.edu> @@ -368,11 +1778,6 @@ 2007-04-06 Andrey Kiselev <dron@ak4719.spb.edu> - * libtiff/tif_dirwrite.c: Fixed swapping of byte arrays stored - in-place in tag offsets as per bug - - http://bugzilla.remotesensing.org/show_bug.cgi?id=1363 - * tools/tiffcrop.c, man/tiffcrop.1: Significant update in functionality from Richard Nolde. As per bug @@ -382,6 +1787,10 @@ * libtiff/tif_fax3.c: "inline static" -> "static inline" for IRIC CC. +2007-03-17 Joris Van Damme <joris.at.lebbeke@skynet.be> + + * start of BigTIFF upgrade - CVS HEAD unstable until further notice + 2007-03-07 Joris Van Damme <joris.at.lebbeke@skynet.be> * libtiff/tif_getimage.c: workaround for 'Fractional scanline' error reading diff --git a/src/3rdparty/libtiff/HOWTO-RELEASE b/src/3rdparty/libtiff/HOWTO-RELEASE deleted file mode 100644 index d6035a5..0000000 --- a/src/3rdparty/libtiff/HOWTO-RELEASE +++ /dev/null @@ -1,105 +0,0 @@ -HOWTO-RELEASE: - -Notes on releasing. - -0. Make sure that you have current FSF releases of autoconf, automake, - and libtool packages installed under a common installation prefix - and that these tools are in your executable search path prior to - any other installed versions. Versions delivered with Linux may be - altered so it is best to install official FSF releases. GNU 'm4' - 1.4.6 or later is needed in order to avoid bugs in m4. These - packages may be downloaded from the following ftp locations: - - autoconf - ftp://ftp.gnu.org/pub/gnu/autoconf - automake - ftp://ftp.gnu.org/pub/gnu/automake - libtool - ftp://ftp.gnu.org/pub/gnu/libtool - - Release builds should only be done on a system with a functioning - and correctly set system clock and on a filesystem which accurately - records file update times. Use of GNU make is recommended. - -1. Commit any unsaved changes. - -2. Create html/vX.X.html. Take ChangeLog entries and html-ify in there. - Easist thing to do is take html/vX.(X-1).html and use it as a template. - Add that file to the list of EXTRA_DIST files in the html/Makefile.am. - -3. Update html/index.html to refer to this new page as the current release. - -4. Increment the release version in configure.ac. Put 'alpha' or - 'beta' after the version, if applicable. For example: - - 3.9.1 - or - 3.9.1beta - - Version should be updated in two places: in the second argument of the - AC_INIT macro and in LIBTIFF_xxx_VERSION variables. - -5. Add an entry to Changelog similar to: - - * libtiff 3.9.1 released. - -6. In the source tree do - - ./autogen.sh - - This step may be skipped if you have already been using a - maintainer build with current autoconf, automake, and libtool - packages. It is only needed when updating tool versions. - -7. It is recommended (but not required) to build outside of the source - tree so that the source tree is kept in a pristine state. This - also allows sharing the source directory on several networked - systems. For example: - - mkdir libtiff-build - cd libtiff-build - /path/to/libtiff/configure --enable-maintainer-mode - - otherwise do - - ./configure --enable-maintainer-mode - -8. In the build tree do - - make release - - This will update "RELEASE-DATE", "VERSION", and libtiff/tiffvers.h - in the source tree. - -9. In the source tree, verify that the version info in RELEASE-DATE, - VERSION and libtiff/tiffvers.h is right. - -10. In the build tree do - - make - make distcheck - - If 'make distcheck' fails, then correct any issues until it - succeeds. - - Two files with names tiff-version.tar.gz and tiff-version.zip will - be created in the top level build directory. - -11. In the source tree do - - 'cvs commit'. - -12. In the source tree do - - cvs tag Release-v3-9-1 - - (or the appropriate name for the release) - -13. Copy release packages from the build tree to the - ftp.remotesensing.org ftp site. - - scp tiff-*.tar.gz tiff-*.zip \ - frankw@upload.osgeo.org:/osgeo/download/libtiff - -14. Announce to list, tiff@lists.maptools.org - -15. Update libtiff page on freshmeat with new version announcement. - - diff --git a/src/3rdparty/libtiff/README b/src/3rdparty/libtiff/README index c0e5521..5f30f4e 100644 --- a/src/3rdparty/libtiff/README +++ b/src/3rdparty/libtiff/README @@ -1,13 +1,15 @@ -$Header: /cvs/maptools/cvsroot/libtiff/README,v 1.5 2004/10/30 13:44:45 dron Exp $ +$Header: /cvs/maptools/cvsroot/libtiff/README,v 1.7 2012-02-18 21:53:27 bfriesen Exp $ TIFF Software Distribution -------------------------- This file is just a placeholder; all the documentation is now in HTML in the html directory. To view the documentation point your -favorite WWW viewer at html/index.html; e.g. +favorite WWW viewer at html/index.html; - netscape html/index.html +e.g. + + firefox html/index.html If you don't have an HTML viewer then you can read the HTML source or fetch a PostScript version of this documentation from the directory diff --git a/src/3rdparty/libtiff/RELEASE-DATE b/src/3rdparty/libtiff/RELEASE-DATE index 1f15bfe..f0326d2 100644 --- a/src/3rdparty/libtiff/RELEASE-DATE +++ b/src/3rdparty/libtiff/RELEASE-DATE @@ -1 +1 @@ -20091104 +20120922 diff --git a/src/3rdparty/libtiff/SConstruct b/src/3rdparty/libtiff/SConstruct deleted file mode 100644 index 682246e..0000000 --- a/src/3rdparty/libtiff/SConstruct +++ /dev/null @@ -1,171 +0,0 @@ -# $Id: SConstruct,v 1.4 2007/02/24 15:03:47 dron Exp $ - -# Tag Image File Format (TIFF) Software -# -# Copyright (C) 2005, Andrey Kiselev <dron@ak4719.spb.edu> -# -# 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. - -# This file contains rules to build software with the SCons tool -# (see the http://www.scons.org/ for details on SCons). - -import os - -env = Environment() - -# Read the user supplied options -opts = Options('libtiff.conf') -opts.Add(PathOption('PREFIX', \ - 'install architecture-independent files in this directory', \ - '/usr/local', PathOption.PathIsDirCreate)) -opts.Add(BoolOption('ccitt', \ - 'enable support for CCITT Group 3 & 4 algorithms', \ - 'yes')) -opts.Add(BoolOption('packbits', \ - 'enable support for Macintosh PackBits algorithm', \ - 'yes')) -opts.Add(BoolOption('lzw', \ - 'enable support for LZW algorithm', \ - 'yes')) -opts.Add(BoolOption('thunder', \ - 'enable support for ThunderScan 4-bit RLE algorithm', \ - 'yes')) -opts.Add(BoolOption('next', \ - 'enable support for NeXT 2-bit RLE algorithm', \ - 'yes')) -opts.Add(BoolOption('logluv', \ - 'enable support for LogLuv high dynamic range encoding', \ - 'yes')) -opts.Add(BoolOption('strip_chopping', \ - 'support for strip chopping (whether or not to convert single-strip uncompressed images to mutiple strips of ~8Kb to reduce memory usage)', \ - 'yes')) -opts.Add(BoolOption('extrasample_as_alpha', \ - 'the RGBA interface will treat a fourth sample with no EXTRASAMPLE_ value as being ASSOCALPHA. Many packages produce RGBA files but don\'t mark the alpha properly', \ - 'yes')) -opts.Add(BoolOption('check_ycbcr_subsampling', \ - 'disable picking up YCbCr subsampling info from the JPEG data stream to support files lacking the tag', \ - 'yes')) -opts.Update(env) -opts.Save('libtiff.conf', env) -Help(opts.GenerateHelpText(env)) - -# Here are our installation paths: -idir_prefix = '$PREFIX' -idir_lib = '$PREFIX/lib' -idir_bin = '$PREFIX/bin' -idir_inc = '$PREFIX/include' -idir_doc = '$PREFIX/doc' -Export([ 'env', 'idir_prefix', 'idir_lib', 'idir_bin', 'idir_inc', 'idir_doc' ]) - -# Now proceed to system feature checks -target_cpu, target_vendor, target_kernel, target_os = \ - os.popen("./config/config.guess").readlines()[0].split("-") - -def Define(context, key, have): - import SCons.Conftest - SCons.Conftest._Have(context, key, have) - -def CheckCustomOption(context, name): - context.Message('Checking is the ' + name + ' option set... ') - ret = env[name] - Define(context, name + '_SUPPORT', ret) - context.Result(ret) - return ret - -def CheckFillorderOption(context): - context.Message('Checking for the native cpu bit order... ') - if target_cpu[0] == 'i' and target_cpu[2:] == '86': - Define(context, 'HOST_FILLORDER', 'FILLORDER_LSB2MSB') - context.Result('lsb2msb') - else: - Define(context, 'HOST_FILLORDER', 'FILLORDER_MSB2LSB') - context.Result('msb2lsb') - return 1 - -def CheckIEEEFPOption(context): - context.Message('Checking for the IEEE floating point format... ') - Define(context, 'HAVE_IEEEFP', 1) - context.Result(1) - return 1 - -def CheckOtherOption(context, name): - context.Message('Checking is the ' + name + ' option set... ') - ret = env[name] - Define(context, 'HAVE_' + name, ret) - context.Result(ret) - return ret - -custom_tests = { \ - 'CheckCustomOption' : CheckCustomOption, \ - 'CheckFillorderOption' : CheckFillorderOption, \ - 'CheckIEEEFPOption' : CheckIEEEFPOption, \ - 'CheckOtherOption' : CheckOtherOption \ - } -conf = Configure(env, custom_tests = custom_tests, \ - config_h = 'libtiff/tif_config.h') - -# Check for standard library -conf.CheckLib('c') -if target_os != 'cygwin' \ - and target_os != 'mingw32' \ - and target_os != 'beos' \ - and target_os != 'darwin': - conf.CheckLib('m') - -# Check for system headers -conf.CheckCHeader('assert.h') -conf.CheckCHeader('fcntl.h') -conf.CheckCHeader('io.h') -conf.CheckCHeader('limits.h') -conf.CheckCHeader('malloc.h') -conf.CheckCHeader('search.h') -conf.CheckCHeader('sys/time.h') -conf.CheckCHeader('unistd.h') - -# Check for standard library functions -conf.CheckFunc('floor') -conf.CheckFunc('isascii') -conf.CheckFunc('memmove') -conf.CheckFunc('memset') -conf.CheckFunc('mmap') -conf.CheckFunc('pow') -conf.CheckFunc('setmode') -conf.CheckFunc('sqrt') -conf.CheckFunc('strchr') -conf.CheckFunc('strrchr') -conf.CheckFunc('strstr') -conf.CheckFunc('strtol') - -conf.CheckFillorderOption() -conf.CheckIEEEFPOption() -conf.CheckCustomOption('ccitt') -conf.CheckCustomOption('packbits') -conf.CheckCustomOption('lzw') -conf.CheckCustomOption('thunder') -conf.CheckCustomOption('next') -conf.CheckCustomOption('logluv') -conf.CheckOtherOption('strip_chopping') -conf.CheckOtherOption('extrasample_as_alpha') -conf.CheckOtherOption('check_ycbcr_subsampling') - -env = conf.Finish() - -# Ok, now go to build files in the subdirectories -SConscript(dirs = [ 'libtiff' ], name = 'SConstruct') diff --git a/src/3rdparty/libtiff/TODO b/src/3rdparty/libtiff/TODO index 6c58eb0..2ff8627 100644 --- a/src/3rdparty/libtiff/TODO +++ b/src/3rdparty/libtiff/TODO @@ -1,4 +1,4 @@ -# $Header: /cvs/maptools/cvsroot/libtiff/TODO,v 1.6 2002/10/10 05:28:43 warmerda Exp $ +# $Header: /cvs/libtiff/TODO,v 1.6 2002/10/10 05:28:43 warmerda Exp $ o gif2tiff segaulting on selected images o tiffcmp read data by strip/tile instead of scanline diff --git a/src/3rdparty/libtiff/VERSION b/src/3rdparty/libtiff/VERSION index 2009c7d..c4e41f9 100644 --- a/src/3rdparty/libtiff/VERSION +++ b/src/3rdparty/libtiff/VERSION @@ -1 +1 @@ -3.9.2 +4.0.3 diff --git a/src/3rdparty/libtiff/html/TIFFTechNote2.html b/src/3rdparty/libtiff/html/TIFFTechNote2.html deleted file mode 100644 index 92bace4..0000000 --- a/src/3rdparty/libtiff/html/TIFFTechNote2.html +++ /dev/null @@ -1,707 +0,0 @@ -<pre> -DRAFT TIFF Technical Note #2 17-Mar-95 -============================ - -This Technical Note describes serious problems that have been found in -TIFF 6.0's design for embedding JPEG-compressed data in TIFF (Section 22 -of the TIFF 6.0 spec of 3 June 1992). A replacement TIFF/JPEG -specification is given. Some corrections to Section 21 are also given. - -To permit TIFF implementations to continue to read existing files, the 6.0 -JPEG fields and tag values will remain reserved indefinitely. However, -TIFF writers are strongly discouraged from using the 6.0 JPEG design. It -is expected that the next full release of the TIFF specification will not -describe the old design at all, except to note that certain tag numbers -are reserved. The existing Section 22 will be replaced by the -specification text given in the second part of this Tech Note. - - -Problems in TIFF 6.0 JPEG -========================= - -Abandoning a published spec is not a step to be taken lightly. This -section summarizes the reasons that have forced this decision. -TIFF 6.0's JPEG design suffers from design errors and limitations, -ambiguities, and unnecessary complexity. - - -Design errors and limitations ------------------------------ - -The fundamental design error in the existing Section 22 is that JPEG's -various tables and parameters are broken out as separate fields which the -TIFF control logic must manage. This is bad software engineering: that -information should be treated as private to the JPEG codec -(compressor/decompressor). Worse, the fields themselves are specified -without sufficient thought for future extension and without regard to -well-established TIFF conventions. Here are some of the significant -problems: - -* The JPEGxxTable fields do not store the table data directly in the -IFD/field structure; rather, the fields hold pointers to information -elsewhere in the file. This requires special-purpose code to be added to -*every* TIFF-manipulating application, whether it needs to decode JPEG -image data or not. Even a trivial TIFF editor, for example a program to -add an ImageDescription field to a TIFF file, must be explicitly aware of -the internal structure of the JPEG-related tables, or else it will probably -break the file. Every other auxiliary field in the TIFF spec contains -data, not pointers, and can be copied or relocated by standard code that -doesn't know anything about the particular field. This is a crucial -property of the TIFF format that must not be given up. - -* To manipulate these fields, the TIFF control logic is required to know a -great deal about JPEG details, for example such arcana as how to compute -the length of a Huffman code table --- the length is not supplied in the -field structure and can only be found by inspecting the table contents. -This is again a violation of good software practice. Moreover, it will -prevent easy adoption of future JPEG extensions that might change these -low-level details. - -* The design neglects the fact that baseline JPEG codecs support only two -sets of Huffman tables: it specifies a separate table for each color -component. This implies that encoders must waste space (by storing -duplicate Huffman tables) or else violate the well-founded TIFF convention -that prohibits duplicate pointers. Furthermore, baseline decoders must -test to find out which tables are identical, a waste of time and code -space. - -* The JPEGInterchangeFormat field also violates TIFF's proscription against -duplicate pointers: the normal strip/tile pointers are expected to point -into the larger data area pointed to by JPEGInterchangeFormat. All TIFF -editing applications must be specifically aware of this relationship, since -they must maintain it or else delete the JPEGInterchangeFormat field. The -JPEGxxTables fields are also likely to point into the JPEGInterchangeFormat -area, creating additional pointer relationships that must be maintained. - -* The JPEGQTables field is fixed at a byte per table entry; there is no -way to support 16-bit quantization values. This is a serious impediment -to extending TIFF to use 12-bit JPEG. - -* The 6.0 design cannot support using different quantization tables in -different strips/tiles of an image (so as to encode some areas at higher -quality than others). Furthermore, since quantization tables are tied -one-for-one to color components, the design cannot support table switching -options that are likely to be added in future JPEG revisions. - - -Ambiguities ------------ - -Several incompatible interpretations are possible for 6.0's treatment of -JPEG restart markers: - - * It is unclear whether restart markers must be omitted at TIFF segment - (strip/tile) boundaries, or whether they are optional. - - * It is unclear whether the segment size is required to be chosen as - a multiple of the specified restart interval (if any); perhaps the - JPEG codec is supposed to be reset at each segment boundary as if - there were a restart marker there, even if the boundary does not fall - at a multiple of the nominal restart interval. - - * The spec fails to address the question of restart marker numbering: - do the numbers begin again within each segment, or not? - -That last point is particularly nasty. If we make numbering begin again -within each segment, we give up the ability to impose a TIFF strip/tile -structure on an existing JPEG datastream with restarts (which was clearly a -goal of Section 22's authors). But the other choice interferes with random -access to the image segments: a reader must compute the first restart -number to be expected within a segment, and must have a way to reset its -JPEG decoder to expect a nonzero restart number first. This may not even -be possible with some JPEG chips. - -The tile height restriction found on page 104 contradicts Section 15's -general description of tiles. For an image that is not vertically -downsampled, page 104 specifies a tile height of one MCU or 8 pixels; but -Section 15 requires tiles to be a multiple of 16 pixels high. - -This Tech Note does not attempt to resolve these ambiguities, so -implementations that follow the 6.0 design should be aware that -inter-application compatibility problems are likely to arise. - - -Unnecessary complexity ----------------------- - -The 6.0 design creates problems for implementations that need to keep the -JPEG codec separate from the TIFF control logic --- for example, consider -using a JPEG chip that was not designed specifically for TIFF. JPEG codecs -generally want to produce or consume a standard ISO JPEG datastream, not -just raw compressed data. (If they were to handle raw data, a separate -out-of-band mechanism would be needed to load tables into the codec.) -With such a codec, the TIFF control logic must parse JPEG markers emitted -by the codec to create the TIFF table fields (when writing) or synthesize -JPEG markers from the TIFF fields to feed the codec (when reading). This -means that the control logic must know a great deal more about JPEG details -than we would like. The parsing and reconstruction of the markers also -represents a fair amount of unnecessary work. - -Quite a few implementors have proposed writing "TIFF/JPEG" files in which -a standard JPEG datastream is simply dumped into the file and pointed to -by JPEGInterchangeFormat. To avoid parsing the JPEG datastream, they -suggest not writing the JPEG auxiliary fields (JPEGxxTables etc) nor even -the basic TIFF strip/tile data pointers. This approach is incompatible -with implementations that handle the full TIFF 6.0 JPEG design, since they -will expect to find strip/tile pointers and auxiliary fields. Indeed this -is arguably not TIFF at all, since *all* TIFF-reading applications expect -to find strip or tile pointers. A subset implementation that is not -upward-compatible with the full spec is clearly unacceptable. However, -the frequency with which this idea has come up makes it clear that -implementors find the existing Section 22 too complex. - - -Overview of the solution -======================== - -To solve these problems, we adopt a new design for embedding -JPEG-compressed data in TIFF files. The new design uses only complete, -uninterpreted ISO JPEG datastreams, so it should be much more forgiving of -extensions to the ISO standard. It should also be far easier to implement -using unmodified JPEG codecs. - -To reduce overhead in multi-segment TIFF files, we allow JPEG overhead -tables to be stored just once in a JPEGTables auxiliary field. This -feature does not violate the integrity of the JPEG datastreams, because it -uses the notions of "tables-only datastreams" and "abbreviated image -datastreams" as defined by the ISO standard. - -To prevent confusion with the old design, the new design is given a new -Compression tag value, Compression=7. Readers that need to handle -existing 6.0 JPEG files may read both old and new files, using whatever -interpretation of the 6.0 spec they did before. Compression tag value 6 -and the field tag numbers defined by 6.0 section 22 will remain reserved -indefinitely, even though detailed descriptions of them will be dropped -from future editions of the TIFF specification. - - -Replacement TIFF/JPEG specification -=================================== - -[This section of the Tech Note is expected to replace Section 22 in the -next release of the TIFF specification.] - -This section describes TIFF compression scheme 7, a high-performance -compression method for continuous-tone images. - -Introduction ------------- - -This TIFF compression method uses the international standard for image -compression ISO/IEC 10918-1, usually known as "JPEG" (after the original -name of the standards committee, Joint Photographic Experts Group). JPEG -is a joint ISO/CCITT standard for compression of continuous-tone images. - -The JPEG committee decided that because of the broad scope of the standard, -no one algorithmic procedure was able to satisfy the requirements of all -applications. Instead, the JPEG standard became a "toolkit" of multiple -algorithms and optional capabilities. Individual applications may select -a subset of the JPEG standard that meets their requirements. - -The most important distinction among the JPEG processes is between lossy -and lossless compression. Lossy compression methods provide high -compression but allow only approximate reconstruction of the original -image. JPEG's lossy processes allow the encoder to trade off compressed -file size against reconstruction fidelity over a wide range. Typically, -10:1 or more compression of full-color data can be obtained while keeping -the reconstructed image visually indistinguishable from the original. Much -higher compression ratios are possible if a low-quality reconstructed image -is acceptable. Lossless compression provides exact reconstruction of the -source data, but the achievable compression ratio is much lower than for -the lossy processes; JPEG's rather simple lossless process typically -achieves around 2:1 compression of full-color data. - -The most widely implemented JPEG subset is the "baseline" JPEG process. -This provides lossy compression of 8-bit-per-channel data. Optional -extensions include 12-bit-per-channel data, arithmetic entropy coding for -better compression, and progressive/hierarchical representations. The -lossless process is an independent algorithm that has little in -common with the lossy processes. - -It should be noted that the optional arithmetic-coding extension is subject -to several US and Japanese patents. To avoid patent problems, use of -arithmetic coding processes in TIFF files intended for inter-application -interchange is discouraged. - -All of the JPEG processes are useful only for "continuous tone" data, -in which the difference between adjacent pixel values is usually small. -Low-bit-depth source data is not appropriate for JPEG compression, nor -are palette-color images good candidates. The JPEG processes work well -on grayscale and full-color data. - -Describing the JPEG compression algorithms in sufficient detail to permit -implementation would require more space than we have here. Instead, we -refer the reader to the References section. - - -What data is being compressed? ------------------------------- - -In lossy JPEG compression, it is customary to convert color source data -to YCbCr and then downsample it before JPEG compression. This gives -2:1 data compression with hardly any visible image degradation, and it -permits additional space savings within the JPEG compression step proper. -However, these steps are not considered part of the ISO JPEG standard. -The ISO standard is "color blind": it accepts data in any color space. - -For TIFF purposes, the JPEG compression tag is considered to represent the -ISO JPEG compression standard only. The ISO standard is applied to the -same data that would be stored in the TIFF file if no compression were -used. Therefore, if color conversion or downsampling are used, they must -be reflected in the regular TIFF fields; these steps are not considered to -be implicit in the JPEG compression tag value. PhotometricInterpretation -and related fields shall describe the color space actually stored in the -file. With the TIFF 6.0 field definitions, downsampling is permissible -only for YCbCr data, and it must correspond to the YCbCrSubSampling field. -(Note that the default value for this field is not 1,1; so the default for -YCbCr is to apply downsampling!) It is likely that future versions of TIFF -will provide additional PhotometricInterpretation values and a more general -way of defining subsampling, so as to allow more flexibility in -JPEG-compressed files. But that issue is not addressed in this Tech Note. - -Implementors should note that many popular JPEG codecs -(compressor/decompressors) provide automatic color conversion and -downsampling, so that the application may supply full-size RGB data which -is nonetheless converted to downsampled YCbCr. This is an implementation -convenience which does not excuse the TIFF control layer from its -responsibility to know what is really going on. The -PhotometricInterpretation and subsampling fields written to the file must -describe what is actually in the file. - -A JPEG-compressed TIFF file will typically have PhotometricInterpretation = -YCbCr and YCbCrSubSampling = [2,1] or [2,2], unless the source data was -grayscale or CMYK. - - -Basic representation of JPEG-compressed images ----------------------------------------------- - -JPEG compression works in either strip-based or tile-based TIFF files. -Rather than repeating "strip or tile" constantly, we will use the term -"segment" to mean either a strip or a tile. - -When the Compression field has the value 7, each image segment contains -a complete JPEG datastream which is valid according to the ISO JPEG -standard (ISO/IEC 10918-1). Any sequential JPEG process can be used, -including lossless JPEG, but progressive and hierarchical processes are not -supported. Since JPEG is useful only for continuous-tone images, the -PhotometricInterpretation of the image shall not be 3 (palette color) nor -4 (transparency mask). The bit depth of the data is also restricted as -specified below. - -Each image segment in a JPEG-compressed TIFF file shall contain a valid -JPEG datastream according to the ISO JPEG standard's rules for -interchange-format or abbreviated-image-format data. The datastream shall -contain a single JPEG frame storing that segment of the image. The -required JPEG markers within a segment are: - SOI (must appear at very beginning of segment) - SOFn - SOS (one for each scan, if there is more than one scan) - EOI (must appear at very end of segment) -The actual compressed data follows SOS; it may contain RSTn markers if DRI -is used. - -Additional JPEG "tables and miscellaneous" markers may appear between SOI -and SOFn, between SOFn and SOS, and before each subsequent SOS if there is -more than one scan. These markers include: - DQT - DHT - DAC (not to appear unless arithmetic coding is used) - DRI - APPn (shall be ignored by TIFF readers) - COM (shall be ignored by TIFF readers) -DNL markers shall not be used in TIFF files. Readers should abort if any -other marker type is found, especially the JPEG reserved markers; -occurrence of such a marker is likely to indicate a JPEG extension. - -The tables/miscellaneous markers may appear in any order. Readers are -cautioned that although the SOFn marker refers to DQT tables, JPEG does not -require those tables to precede the SOFn, only the SOS. Missing-table -checks should be made when SOS is reached. - -If no JPEGTables field is used, then each image segment shall be a complete -JPEG interchange datastream. Each segment must define all the tables it -references. To allow readers to decode segments in any order, no segment -may rely on tables being carried over from a previous segment. - -When a JPEGTables field is used, image segments may omit tables that have -been specified in the JPEGTables field. Further details appear below. - -The SOFn marker shall be of type SOF0 for strict baseline JPEG data, of -type SOF1 for non-baseline lossy JPEG data, or of type SOF3 for lossless -JPEG data. (SOF9 or SOF11 would be used for arithmetic coding.) All -segments of a JPEG-compressed TIFF image shall use the same JPEG -compression process, in particular the same SOFn type. - -The data precision field of the SOFn marker shall agree with the TIFF -BitsPerSample field. (Note that when PlanarConfiguration=1, this implies -that all components must have the same BitsPerSample value; when -PlanarConfiguration=2, different components could have different bit -depths.) For SOF0 only precision 8 is permitted; for SOF1, precision 8 or -12 is permitted; for SOF3, precisions 2 to 16 are permitted. - -The image dimensions given in the SOFn marker shall agree with the logical -dimensions of that particular strip or tile. For strip images, the SOFn -image width shall equal ImageWidth and the height shall equal RowsPerStrip, -except in the last strip; its SOFn height shall equal the number of rows -remaining in the ImageLength. (In other words, no padding data is counted -in the SOFn dimensions.) For tile images, each SOFn shall have width -TileWidth and height TileHeight; adding and removing any padding needed in -the edge tiles is the concern of some higher level of the TIFF software. -(The dimensional rules are slightly different when PlanarConfiguration=2, -as described below.) - -The ISO JPEG standard only permits images up to 65535 pixels in width or -height, due to 2-byte fields in the SOFn markers. In TIFF, this limits -the size of an individual JPEG-compressed strip or tile, but the total -image size can be greater. - -The number of components in the JPEG datastream shall equal SamplesPerPixel -for PlanarConfiguration=1, and shall be 1 for PlanarConfiguration=2. The -components shall be stored in the same order as they are described at the -TIFF field level. (This applies both to their order in the SOFn marker, -and to the order in which they are scanned if multiple JPEG scans are -used.) The component ID bytes are arbitrary so long as each component -within an image segment is given a distinct ID. To avoid any possible -confusion, we require that all segments of a TIFF image use the same ID -code for a given component. - -In PlanarConfiguration 1, the sampling factors given in SOFn markers shall -agree with the sampling factors defined by the related TIFF fields (or with -the default values that are specified in the absence of those fields). - -When DCT-based JPEG is used in a strip TIFF file, RowsPerStrip is required -to be a multiple of 8 times the largest vertical sampling factor, i.e., a -multiple of the height of an interleaved MCU. (For simplicity of -specification, we require this even if the data is not actually -interleaved.) For example, if YCbCrSubSampling = [2,2] then RowsPerStrip -must be a multiple of 16. An exception to this rule is made for -single-strip images (RowsPerStrip >= ImageLength): the exact value of -RowsPerStrip is unimportant in that case. This rule ensures that no data -padding is needed at the bottom of a strip, except perhaps the last strip. -Any padding required at the right edge of the image, or at the bottom of -the last strip, is expected to occur internally to the JPEG codec. - -When DCT-based JPEG is used in a tiled TIFF file, TileLength is required -to be a multiple of 8 times the largest vertical sampling factor, i.e., -a multiple of the height of an interleaved MCU; and TileWidth is required -to be a multiple of 8 times the largest horizontal sampling factor, i.e., -a multiple of the width of an interleaved MCU. (For simplicity of -specification, we require this even if the data is not actually -interleaved.) All edge padding required will therefore occur in the course -of normal TIFF tile padding; it is not special to JPEG. - -Lossless JPEG does not impose these constraints on strip and tile sizes, -since it is not DCT-based. - -Note that within JPEG datastreams, multibyte values appear in the MSB-first -order specified by the JPEG standard, regardless of the byte ordering of -the surrounding TIFF file. - - -JPEGTables field ----------------- - -The only auxiliary TIFF field added for Compression=7 is the optional -JPEGTables field. The purpose of JPEGTables is to predefine JPEG -quantization and/or Huffman tables for subsequent use by JPEG image -segments. When this is done, these rather bulky tables need not be -duplicated in each segment, thus saving space and processing time. -JPEGTables may be used even in a single-segment file, although there is no -space savings in that case. - -JPEGTables: - Tag = 347 (15B.H) - Type = UNDEFINED - N = number of bytes in tables datastream, typically a few hundred -JPEGTables provides default JPEG quantization and/or Huffman tables which -are used whenever a segment datastream does not contain its own tables, as -specified below. - -Notice that the JPEGTables field is required to have type code UNDEFINED, -not type code BYTE. This is to cue readers that expanding individual bytes -to short or long integers is not appropriate. A TIFF reader will generally -need to store the field value as an uninterpreted byte sequence until it is -fed to the JPEG decoder. - -Multibyte quantities within the tables follow the ISO JPEG convention of -MSB-first storage, regardless of the byte ordering of the surrounding TIFF -file. - -When the JPEGTables field is present, it shall contain a valid JPEG -"abbreviated table specification" datastream. This datastream shall begin -with SOI and end with EOI. It may contain zero or more JPEG "tables and -miscellaneous" markers, namely: - DQT - DHT - DAC (not to appear unless arithmetic coding is used) - DRI - APPn (shall be ignored by TIFF readers) - COM (shall be ignored by TIFF readers) -Since JPEG defines the SOI marker to reset the DAC and DRI state, these two -markers' values cannot be carried over into any image datastream, and thus -they are effectively no-ops in the JPEGTables field. To avoid confusion, -it is recommended that writers not place DAC or DRI markers in JPEGTables. -However readers must properly skip over them if they appear. - -When JPEGTables is present, readers shall load the table specifications -contained in JPEGTables before processing image segment datastreams. -Image segments may simply refer to these preloaded tables without defining -them. An image segment can still define and use its own tables, subject to -the restrictions below. - -An image segment may not redefine any table defined in JPEGTables. (This -restriction is imposed to allow readers to process image segments in random -order without having to reload JPEGTables between segments.) Therefore, use -of JPEGTables divides the available table slots into two groups: "global" -slots are defined in JPEGTables and may be used but not redefined by -segments; "local" slots are available for local definition and use in each -segment. To permit random access, a segment may not reference any local -tables that it does not itself define. - - -Special considerations for PlanarConfiguration 2 ------------------------------------------------- - -In PlanarConfiguration 2, each image segment contains data for only one -color component. To avoid confusing the JPEG codec, we wish the segments -to look like valid single-channel (i.e., grayscale) JPEG datastreams. This -means that different rules must be used for the SOFn parameters. - -In PlanarConfiguration 2, the dimensions given in the SOFn of a subsampled -component shall be scaled down by the sampling factors compared to the SOFn -dimensions that would be used in PlanarConfiguration 1. This is necessary -to match the actual number of samples stored in that segment, so that the -JPEG codec doesn't complain about too much or too little data. In strip -TIFF files the computed dimensions may need to be rounded up to the next -integer; in tiled files, the restrictions on tile size make this case -impossible. - -Furthermore, all SOFn sampling factors shall be given as 1. (This is -merely to avoid confusion, since the sampling factors in a single-channel -JPEG datastream have no real effect.) - -Any downsampling will need to happen externally to the JPEG codec, since -JPEG sampling factors are defined with reference to the full-precision -component. In PlanarConfiguration 2, the JPEG codec will be working on -only one component at a time and thus will have no reference component to -downsample against. - - -Minimum requirements for TIFF/JPEG ----------------------------------- - -ISO JPEG is a large and complex standard; most implementations support only -a subset of it. Here we define a "core" subset of TIFF/JPEG which readers -must support to claim TIFF/JPEG compatibility. For maximum -cross-application compatibility, we recommend that writers confine -themselves to this subset unless there is very good reason to do otherwise. - -Use the ISO baseline JPEG process: 8-bit data precision, Huffman coding, -with no more than 2 DC and 2 AC Huffman tables. Note that this implies -BitsPerSample = 8 for each component. We recommend deviating from baseline -JPEG only if 12-bit data precision or lossless coding is required. - -Use no subsampling (all JPEG sampling factors = 1) for color spaces other -than YCbCr. (This is, in fact, required with the TIFF 6.0 field -definitions, but may not be so in future revisions.) For YCbCr, use one of -the following choices: - YCbCrSubSampling field JPEG sampling factors - 1,1 1h1v, 1h1v, 1h1v - 2,1 2h1v, 1h1v, 1h1v - 2,2 (default value) 2h2v, 1h1v, 1h1v -We recommend that RGB source data be converted to YCbCr for best compression -results. Other source data colorspaces should probably be left alone. -Minimal readers need not support JPEG images with colorspaces other than -YCbCr and grayscale (PhotometricInterpretation = 6 or 1). - -A minimal reader also need not support JPEG YCbCr images with nondefault -values of YCbCrCoefficients or YCbCrPositioning, nor with values of -ReferenceBlackWhite other than [0,255,128,255,128,255]. (These values -correspond to the RGB<=>YCbCr conversion specified by JFIF, which is widely -implemented in JPEG codecs.) - -Writers are reminded that a ReferenceBlackWhite field *must* be included -when PhotometricInterpretation is YCbCr, because the default -ReferenceBlackWhite values are inappropriate for YCbCr. - -If any subsampling is used, PlanarConfiguration=1 is preferred to avoid the -possibly-confusing requirements of PlanarConfiguration=2. In any case, -readers are not required to support PlanarConfiguration=2. - -If possible, use a single interleaved scan in each image segment. This is -not legal JPEG if there are more than 4 SamplesPerPixel or if the sampling -factors are such that more than 10 blocks would be needed per MCU; in that -case, use a separate scan for each component. (The recommended color -spaces and sampling factors will not run into that restriction, so a -minimal reader need not support more than one scan per segment.) - -To claim TIFF/JPEG compatibility, readers shall support multiple-strip TIFF -files and the optional JPEGTables field; it is not acceptable to read only -single-datastream files. Support for tiled TIFF files is strongly -recommended but not required. - - -Other recommendations for implementors --------------------------------------- - -The TIFF tag Compression=7 guarantees only that the compressed data is -represented as ISO JPEG datastreams. Since JPEG is a large and evolving -standard, readers should apply careful error checking to the JPEG markers -to ensure that the compression process is within their capabilities. In -particular, to avoid being confused by future extensions to the JPEG -standard, it is important to abort if unknown marker codes are seen. - -The point of requiring that all image segments use the same JPEG process is -to ensure that a reader need check only one segment to determine whether it -can handle the image. For example, consider a TIFF reader that has access -to fast but restricted JPEG hardware, as well as a slower, more general -software implementation. It is desirable to check only one image segment -to find out whether the fast hardware can be used. Thus, writers should -try to ensure that all segments of an image look as much "alike" as -possible: there should be no variation in scan layout, use of options such -as DRI, etc. Ideally, segments will be processed identically except -perhaps for using different local quantization or entropy-coding tables. - -Writers should avoid including "noise" JPEG markers (COM and APPn markers). -Standard TIFF fields provide a better way to transport any non-image data. -Some JPEG codecs may change behavior if they see an APPn marker they -think they understand; since the TIFF spec requires these markers to be -ignored, this behavior is undesirable. - -It is possible to convert an interchange-JPEG file (e.g., a JFIF file) to -TIFF simply by dropping the interchange datastream into a single strip. -(However, designers are reminded that the TIFF spec discourages huge -strips; splitting the image is somewhat more work but may give better -results.) Conversion from TIFF to interchange JPEG is more complex. A -strip-based TIFF/JPEG file can be converted fairly easily if all strips use -identical JPEG tables and no RSTn markers: just delete the overhead markers -and insert RSTn markers between strips. Converting tiled images is harder, -since the data will usually not be in the right order (unless the tiles are -only one MCU high). This can still be done losslessly, but it will require -undoing and redoing the entropy coding so that the DC coefficient -differences can be updated. - -There is no default value for JPEGTables: standard TIFF files must define all -tables that they reference. For some closed systems in which many files will -have identical tables, it might make sense to define a default JPEGTables -value to avoid actually storing the tables. Or even better, invent a -private field selecting one of N default JPEGTables settings, so as to allow -for future expansion. Either of these must be regarded as a private -extension that will render the files unreadable by other applications. - - -References ----------- - -[1] Wallace, Gregory K. "The JPEG Still Picture Compression Standard", -Communications of the ACM, April 1991 (vol. 34 no. 4), pp. 30-44. - -This is the best short technical introduction to the JPEG algorithms. -It is a good overview but does not provide sufficiently detailed -information to write an implementation. - -[2] Pennebaker, William B. and Mitchell, Joan L. "JPEG Still Image Data -Compression Standard", Van Nostrand Reinhold, 1993, ISBN 0-442-01272-1. -638pp. - -This textbook is by far the most complete exposition of JPEG in existence. -It includes the full text of the ISO JPEG standards (DIS 10918-1 and draft -DIS 10918-2). No would-be JPEG implementor should be without it. - -[3] ISO/IEC IS 10918-1, "Digital Compression and Coding of Continuous-tone -Still Images, Part 1: Requirements and guidelines", February 1994. -ISO/IEC DIS 10918-2, "Digital Compression and Coding of Continuous-tone -Still Images, Part 2: Compliance testing", final approval expected 1994. - -These are the official standards documents. Note that the Pennebaker and -Mitchell textbook is likely to be cheaper and more useful than the official -standards. - - -Changes to Section 21: YCbCr Images -=================================== - -[This section of the Tech Note clarifies section 21 to make clear the -interpretation of image dimensions in a subsampled image. Furthermore, -the section is changed to allow the original image dimensions not to be -multiples of the sampling factors. This change is necessary to support use -of JPEG compression on odd-size images.] - -Add the following paragraphs to the Section 21 introduction (p. 89), -just after the paragraph beginning "When a Class Y image is subsampled": - - In a subsampled image, it is understood that all TIFF image - dimensions are measured in terms of the highest-resolution - (luminance) component. In particular, ImageWidth, ImageLength, - RowsPerStrip, TileWidth, TileLength, XResolution, and YResolution - are measured in luminance samples. - - RowsPerStrip, TileWidth, and TileLength are constrained so that - there are an integral number of samples of each component in a - complete strip or tile. However, ImageWidth/ImageLength are not - constrained. If an odd-size image is to be converted to subsampled - format, the writer should pad the source data to a multiple of the - sampling factors by replication of the last column and/or row, then - downsample. The number of luminance samples actually stored in the - file will be a multiple of the sampling factors. Conversely, - readers must ignore any extra data (outside the specified image - dimensions) after upsampling. - - When PlanarConfiguration=2, each strip or tile covers the same - image area despite subsampling; that is, the total number of strips - or tiles in the image is the same for each component. Therefore - strips or tiles of the subsampled components contain fewer samples - than strips or tiles of the luminance component. - - If there are extra samples per pixel (see field ExtraSamples), - these data channels have the same number of samples as the - luminance component. - -Rewrite the YCbCrSubSampling field description (pp 91-92) as follows -(largely to eliminate possibly-misleading references to -ImageWidth/ImageLength of the subsampled components): - - (first paragraph unchanged) - - The two elements of this field are defined as follows: - - Short 0: ChromaSubsampleHoriz: - - 1 = there are equal numbers of luma and chroma samples horizontally. - - 2 = there are twice as many luma samples as chroma samples - horizontally. - - 4 = there are four times as many luma samples as chroma samples - horizontally. - - Short 1: ChromaSubsampleVert: - - 1 = there are equal numbers of luma and chroma samples vertically. - - 2 = there are twice as many luma samples as chroma samples - vertically. - - 4 = there are four times as many luma samples as chroma samples - vertically. - - ChromaSubsampleVert shall always be less than or equal to - ChromaSubsampleHoriz. Note that Cb and Cr have the same sampling - ratios. - - In a strip TIFF file, RowsPerStrip is required to be an integer - multiple of ChromaSubSampleVert (unless RowsPerStrip >= - ImageLength, in which case its exact value is unimportant). - If ImageWidth and ImageLength are not multiples of - ChromaSubsampleHoriz and ChromaSubsampleVert respectively, then the - source data shall be padded to the next integer multiple of these - values before downsampling. - - In a tiled TIFF file, TileWidth must be an integer multiple of - ChromaSubsampleHoriz and TileLength must be an integer multiple of - ChromaSubsampleVert. Padding will occur to tile boundaries. - - The default values of this field are [ 2,2 ]. Thus, YCbCr data is - downsampled by default! -</pre> diff --git a/src/3rdparty/libtiff/html/addingtags.html b/src/3rdparty/libtiff/html/addingtags.html deleted file mode 100644 index 452821c..0000000 --- a/src/3rdparty/libtiff/html/addingtags.html +++ /dev/null @@ -1,292 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Modifying The TIFF Library -</TITLE> -</HEAD> -<BODY BGCOLOR=white> -<FONT FACE="Arial, Helvetica, Sans"> - -<H1> -Defining New TIFF Tags -</H1> - -Libtiff has built-in knowledge of all the standard TIFF tags, as -well as extentions. The following describes how to add knowledge of -new tags as builtins to libtiff, or how to application specific tags can -be used by applications without modifying libtiff. -<p> - -<h2>TIFFFieldInfo</h2> - -How libtiff manages specific tags is primarily controlled by the -definition for that tag value stored internally as a TIFFFieldInfo structure. -This structure looks like this: -<p> - -<pre> -typedef struct { - ttag_t field_tag; /* field's tag */ - short field_readcount; /* read count/TIFF_VARIABLE/TIFF_SPP */ - short field_writecount; /* write count/TIFF_VARIABLE */ - TIFFDataType field_type; /* type of associated data */ - unsigned short field_bit; /* bit in fieldsset bit vector */ - unsigned char field_oktochange;/* if true, can change while writing */ - unsigned char field_passcount;/* if true, pass dir count on set */ - char *field_name; /* ASCII name */ -} TIFFFieldInfo; -</pre> - -<ul> -<li> <b>field_tag</b>: the tag number. For instance 277 for the -SamplesPerPixel tag. Builtin tags will generally have a #define in -tiff.h for each known tag. <p> - -<li> <b>field_readcount</b>: The number of values which should be read. -The special value TIFF_VARIABLE (-1) indicates that a variable number of -values may be read. The special value TIFFTAG_SPP (-2) indicates that there -should be one value for each sample as defined by TIFFTAG_SAMPLESPERPIXEL. -The special value TIFF_VARIABLE2 (-3) is presumably similar to TIFF_VARIABLE -though I am not sure what the distinction in behaviour is. This field -is TIFF_VARIABLE for variable length ascii fields.<p> - -<li> <b>field_writecount</b>: The number of values which should be written. -Generally the same as field_readcount. A few built-in exceptions exist, but -I haven't analysed why they differ. <p> - -<li> <b>field_type</b>: Type of the field. One of TIFF_BYTE, TIFF_ASCII, -TIFF_SHORT, TIFF_LONG, TIFF_RATIONAL, TIFF_SBYTE, TIFF_UNDEFINED, -TIFF_SSHORT, TIFF_SLONG, TIFF_SRATIONAL, TIFF_FLOAT, TIFF_DOUBLE or -TIFF_IFD. Note that some fields can support more than one type (for -instance short and long). These fields should have multiple TIFFFieldInfos. -<p> - -<li> <b>field_bit</b>: Built-in tags stored in special fields in the -TIFF structure have assigned field numbers to distinguish them (ie. -FIELD_SAMPLESPERPIXEL). New tags should generally just use -FIELD_CUSTOM indicating they are stored in the generic tag list.<p> - -<li> <b>field_oktochange</b>: TRUE if it is OK to change this tag value -while an image is being written. FALSE for stuff that must be set once -and then left unchanged (like ImageWidth, or PhotometricInterpretation for -instance).<p> - -<li> <b>field_passcount</b>: If TRUE, then the count value must be passed -in TIFFSetField(), and TIFFGetField(), otherwise the count is not required. -This should generally be TRUE for non-ascii variable count tags unless -the count is implicit (such as with the colormap).<p> - -<li> <b>field_name</b>: A name for the tag. Normally mixed case (studly caps) -like "StripByteCounts" and relatively short. <p> - -</ul> - -A TIFFFieldInfo definition exists for each built-in tag in the tif_dirinfo.c -file. Some tags which support multiple data types have more than one -definition, one per data type supported. <p> - -Various functions exist for getting the internal TIFFFieldInfo definitions, -including _TIFFFindFieldInfo(), and _TIFFFindFieldInfoByName(). See -tif_dirinfo.c for details. There must be some mechanism to get the whole -list, though I don't see it off hand.<p> - -<h2>Default Tag Auto-registration</h2> - -In libtiff 3.6.0 a new mechanism was introduced allowing libtiff to -read unrecognised tags automatically. When an unknown tags is encountered, -it is automatically internally defined with a default name and a type -derived from the tag value in the file. Applications only need to predefine -application specific tags if they need to be able to set them in a file, or -if particular calling conventions are desired for TIFFSetField() and -TIFFGetField().<p> - -When tags are autodefined like this the <b>field_readcount</b> and -<b>field_writecount</b> values are always TIFF_VARIABLE. The -<b>field_passcount</b> is always TRUE, and the <b>field_bit</b> is -FIELD_CUSTOM. The field name will be "Tag %d" where the %d is the tag -number.<p> - -<h2>Defining Application Tags</h2> - -For various reasons, it is common for applications to want to define -their own tags to store information outside the core TIFF specification. -This is done by calling TIFFMergeFieldInfo() with one or more TIFFFieldInfos. -<p> - -The libgeotiff library provides geospatial information extentions within -a TIFF file. First, a set of TIFFFieldInfo's is prepared with information -on the new tags:<p> - -<pre> -static const TIFFFieldInfo xtiffFieldInfo[] = { - - /* XXX Insert Your tags here */ - { TIFFTAG_GEOPIXELSCALE, -1,-1, TIFF_DOUBLE, FIELD_CUSTOM, - TRUE, TRUE, "GeoPixelScale" }, - { TIFFTAG_GEOTRANSMATRIX, -1,-1, TIFF_DOUBLE, FIELD_CUSTOM, - TRUE, TRUE, "GeoTransformationMatrix" }, - { TIFFTAG_GEOTIEPOINTS, -1,-1, TIFF_DOUBLE, FIELD_CUSTOM, - TRUE, TRUE, "GeoTiePoints" }, - { TIFFTAG_GEOKEYDIRECTORY, -1,-1, TIFF_SHORT, FIELD_CUSTOM, - TRUE, TRUE, "GeoKeyDirectory" }, - { TIFFTAG_GEODOUBLEPARAMS, -1,-1, TIFF_DOUBLE, FIELD_CUSTOM, - TRUE, TRUE, "GeoDoubleParams" }, - { TIFFTAG_GEOASCIIPARAMS, -1,-1, TIFF_ASCII, FIELD_CUSTOM, - TRUE, FALSE, "GeoASCIIParams" } -}; -</pre> - -In order to define the tags, we call TIFFMergeFieldInfo() on the -desired TIFF handle with the list of TIFFFieldInfos.<p> - -<pre> -#define N(a) (sizeof (a) / sizeof (a[0])) - - /* Install the extended Tag field info */ - TIFFMergeFieldInfo(tif, xtiffFieldInfo, N(xtiffFieldInfo)); -</pre> - -The tags need to be defined for each TIFF file opened - and when reading -they should be defined before the tags of the file are read, yet a valid -TIFF * is needed to merge the tags against. In order to get them -registered at the appropriate part of the setup process, it is necessary -to register our merge function as an extender callback with libtiff. -This is done with TIFFSetTagExtender(). We also keep track of the -previous tag extender (if any) so that we can call it from our extender -allowing a chain of customizations to take effect. <P> - -<pre> -static TIFFExtendProc _ParentExtender = NULL; - -static -void _XTIFFInitialize(void) -{ - static int first_time=1; - - if (! first_time) return; /* Been there. Done that. */ - first_time = 0; - - /* Grab the inherited method and install */ - _ParentExtender = TIFFSetTagExtender(_XTIFFDefaultDirectory); -} -</pre> - -The extender callback is looks like this. It merges in our new fields -and then calls the next extender if there is one in effect.<p> - -<pre> -static void -_XTIFFDefaultDirectory(TIFF *tif) -{ - /* Install the extended Tag field info */ - TIFFMergeFieldInfo(tif, xtiffFieldInfo, N(xtiffFieldInfo)); - - /* Since an XTIFF client module may have overridden - * the default directory method, we call it now to - * allow it to set up the rest of its own methods. - */ - - if (_ParentExtender) - (*_ParentExtender)(tif); -} -</pre> - -The above approach ensures that our new definitions are used when reading -or writing any TIFF file. However, since on reading we already have -default definitions for tags, it is usually not critical to pre-define them. -If tag definitions are only required for writing custom tags, you can just -call TIFFMergeFieldInfo() before setting new tags. The whole extender -architecture can then be avoided.<p> - -<A NAME=AddingTags><P><H2>Adding New Builtin Tags</H2></A> - -A similar approach is taken to the above. However, the TIFFFieldInfo -should be added to the tiffFieldInfo[] list in tif_dirinfo.c. Ensure that -new tags are added in sorted order by the tag number.<p> - -Normally new built-in tags should be defined with FIELD_CUSTOM; however, if -it is desirable for the tag value to have it's own field in the TIFFDirectory -structure, then you will need to #define a new FIELD_ value for it, and -add appropriate handling as follows: - - -<OL> -<LI>Define the tag in <B>tiff.h</B>. -<LI>Add a field to the directory structure in <B>tif_dir.h</B> - and define a <TT>FIELD_*</TT> bit (also update the definition of - <TT>FIELD_CODEC</TT> to reflect your addition). -<LI>Add an entry in the <TT>TIFFFieldInfo</TT> array defined at the top of - <B>tif_dirinfo.c</B>. - Note that you must keep this array sorted by tag - number and that the widest variant entry for a tag should come - first (e.g. <TT>LONG</TT> before <TT>SHORT</TT>). -<LI>Add entries in <TT>_TIFFVSetField()</TT> and <TT>_TIFFVGetField()</TT> - for the new tag. -<LI>(<I>optional</I>) If the value associated with the tag is not a scalar value - (e.g. the array for <TT>TransferFunction</TT>) and requires - special processing, - then add the appropriate code to <TT>TIFFReadDirectory()</TT> and - <TT>TIFFWriteDirectory()</TT>. You're best off finding a similar tag and - cribbing code. -<LI>Add support to <TT>TIFFPrintDirectory()</TT> in <B>tif_print.c</B> - to print the tag's value. -</OL> - -<P> -If you want to maintain portability, beware of making assumptions -about data types. Use the typedefs (<TT>uint16</TT>, etc. when dealing with -data on disk and <TT>t*_t</TT> when stuff is in memory) and be careful about -passing items through printf or similar vararg interfaces. - -<A NAME=AddingCODECTags><P><H2>Adding New Codec-private Tags</H2></A> - -To add tags that are meaningful <EM>only when a particular compression -algorithm is used</EM> follow these steps: - -<OL> -<LI>Define the tag in <B>tiff.h</B>. -<LI>Allocate storage for the tag values in the private state block of - the codec. -<LI>Insure the state block is created when the codec is initialized. -<LI>At <TT>TIFFInitfoo</TT> time override the method pointers in the - TIFF structure - for getting, setting and printing tag values. For example, -<PRE> - sp->vgetparent = tif->tif_vgetfield; - tif->tif_vgetfield = fooVGetField; /* hook for codec tags */ - sp->vsetparent = tif->tif_vsetfield; - tif->tif_vsetfield = fooVSetField; /* hook for codec tags */ - tif->tif_printdir = fooPrintDir; /* hook for codec tags */ -</PRE> - (Actually you may decide not to override the - <TT>tif_printdir</TT> method, but rather just specify it). -<LI>Create a private <TT>TIFFFieldInfo</TT> array for your tags and - merge them into the core tags at initialization time using - <TT>_TIFFMergeFieldInfo</TT>; e.g. -<PRE> - _TIFFMergeFieldInfo(tif, fooFieldInfo, N(fooFieldInfo)); -</PRE> - (where <TT>N</TT> is a macro used liberaly throughout the distributed code). -<LI>Fill in the get and set routines. Be sure to call the parent method - for tags that you are not handled directly. Also be sure to set the - <TT>FIELD_*</TT> bits for tags that are to be written to the file. Note that - you can create ``pseudo-tags'' by defining tags that are processed - exclusively in the get/set routines and never written to file (see - the handling of <TT>TIFFTAG_FAXMODE</TT> in <B>tif_fax3.c</B> - for an example of this). -<LI>Fill in the print routine, if appropriate. -</OL> - -Note that space has been allocated in the <TT>FIELD_*</TT> bit space for -codec-private tags. Define your bits as <TT>FIELD_CODEC+<offset></TT> to -keep them away from the core tags. If you need more tags than there -is room for, just increase <TT>FIELD_SETLONGS</TT> at the top of -<B>tiffiop.h</B>. - -<HR> - -Last updated: $Date: 2004/09/10 14:43:18 $ - -</BODY> - -</HTML> diff --git a/src/3rdparty/libtiff/html/bugs.html b/src/3rdparty/libtiff/html/bugs.html deleted file mode 100644 index dd17c73..0000000 --- a/src/3rdparty/libtiff/html/bugs.html +++ /dev/null @@ -1,63 +0,0 @@ -<HTML> -<HEAD> -<TITLE>Bugs and the TIFF Mailing List</TITLE> -</HEAD> -<BODY BGCOLOR=white> -<FONT FACE="Arial, Helvetica, Sans"> -<H1> -<IMG SRC=images/cover.jpg WIDTH=110 HEIGHT=110 ALIGN=left BORDER=1 HSPACE=6> -Bugs, Bugzilla, and the TIFF Mailing List -</H1> - -<P> -This software is free. Please let us know when you find a problem or -fix a bug. - -<P> -Thanks to <A HREF=http://www.maptools.org/>MapTools.org</a>, libtiff now uses -bugzilla to track bugs. All bugs filed in the older bugzilla at -bugzilla.remotesensing.org (pre April 2008) have unfortunately been lost. -<P> -If you think you've discovered a bug, please first check to see if it is -already known by looking at the list of already reported bugs. You can do so -by visiting the buglist at -<A HREF=http://bugzilla.maptools.org/buglist.cgi?product=libtiff>http://bugzilla.maptools.org/buglist.cgi?product=libtiff</A>. Also verify that -the problem is still reproducable with the current development software -from CVS. -<P> -If you'd like to enter a new bug, you can do so at -<A HREF=http://bugzilla.maptools.org/enter_bug.cgi?product=libtiff>http://bugzilla.maptools.org/enter_bug.cgi?product=libtiff</A>. -<P> -If you'd like to inform us about some kind of security issue that should not -be disclosed for a period of time, then you can contact maintainers directly. -Send a copies of your report to the following people: Frank Warmerdam -<a href="mailto:warmerdam@pobox.com"><warmerdam@pobox.com></a>, -Andrey Kiselev -<a href="mailto:dron@ak4719.spb.edu"><dron@ak4719.spb.edu></a>. -<P> - -Of course, reporting bugs is no substitute for discussion. The -<a href="mailto:tiff@lists.maptools.org">tiff@lists.maptools.org</a> mailing -list is for users of this software, and discussion TIFF issues in general. -It is managed with the Mailman software, and the web interface for subscribing -and managing your access to the list is at:<p> - - <a href="http://lists.maptools.org/mailman/listinfo/tiff">http://lists.maptools.org/mailman/listinfo/tiff</a><P> - -Posts to the list are only accepted from members of the list in order -to limit the amount of spam propagated. Also, to be approved as a member -you will need to email the list administrator with a brief description of -why you are interested in TIFF so we can weed out spammers.<p> - -A <A HREF="http://www.awaresystems.be/imaging/tiff/tml.html">Long Term -Archive</a> including recent messages, and most messages back to 1993, -with search capabilities is available, and -has been prepared and hosted by <a href="http://www.awaresystems.be">AWare -Systems</a>. <p> - - -<HR> - -Last updated: $Date: 2008/09/03 08:04:26 $ -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/build.html b/src/3rdparty/libtiff/html/build.html deleted file mode 100644 index e0b2157..0000000 --- a/src/3rdparty/libtiff/html/build.html +++ /dev/null @@ -1,880 +0,0 @@ -<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html> -<head> -<meta name="generator" content= -"HTML Tidy for Solaris (vers 12 April 2005), see www.w3.org"> -<title>Building the TIFF Software Distribution</title> -</head> -<body bgcolor="white"> -<h1><font face="Arial, Helvetica, Sans"><img src= -"images/cramps.gif" width="159" height="203" align="left" border= -"1" hspace="6"> Building the Software Distribution</font></h1> -<ul> -<li><a href="#UNIX">Building on a UNIX system</a>.</li> -<li><a href="#MacMPW">Building on a Macintosh system with -MPW</a>.</li> -<li><a href="#MacCW">Building on a Macintosh system with -CodeWarrior</a>.</li> -<li><a href="#PC">Building on an MS-DOS or Windows system</a>.</li> -<li><a href="#DJGPP">Building on MS-DOS with the DJGPP v2 -compiler</a>.</li> -<li><a href="#VMS">Building on a VMS system</a>.</li> -<li><a href="#Acorn">Building on an Acorn RISC OS system</a>.</li> -<li><a href="#Other">Building the Software on Other -Systems</a></li> -</ul> -<br clear="left"> -This chapter contains step-by-step instructions on how to configure -and build the TIFF software distribution. The software is most -easily built on a UNIX system, but with a little bit of work it can -easily be built and used on other non-UNIX platforms. <a name= -"UNIX" id="UNIX"></a> -<hr> -<h2>Building on a UNIX System</h2> -To build the software on a UNIX system you need to first run the -configure shell script that is located in the top level of the -source directory. This script probes the target system for -necessary tools and functions and constructs a build environment in -which the software may be compiled. Once configuration is done, you -simply run <tt>make</tt> (or <tt>gmake</tt>) to build the software -and then <tt>make install</tt> to do the installation; for example: -<div style="margin-left: 2em"> -<pre> -hyla% <b>cd tiff-v3.4beta099</b> -hyla% <b>./configure</b> - <i>...lots of messages...</i> -hyla% <b>make</b> - <i>...lots of messages...</i> -hyla# <b>make install</b> -</pre></div> -Supplied makefiles are depend on GNU <tt>make</tt> utility, so you -will need the one. Depending on your installation <b>make</b> -command may invoke standard system <tt>make</tt> and <b>gmake</b> -invoke GNU make. In this case you should use former. If you don't -have <tt>make</tt> at all, but only <tt>gmake</tt>, you should -export environment variable <tt>MAKE=gmake</tt> before -<b>./configure</b>. -<p>In general, the software is designed such that the following -should be ``<i>make-able</i>'' in each directory:</p> -<div style="margin-left: 2em"> -<pre> -make [all] build stuff -make install build&install stuff -make clean remove .o files, executables and cruft -make distclean remove everything, that can be recreated -</pre></div> -Note that after running "<tt>make distclean</tt>" the -<tt>configure</tt> script must be run again to create the Makefiles -and other make-related files. <a name="BuildTrees" id= -"BuildTrees"></a> -<hr width="65%" align="right"> -<h3>Build Trees</h3> -There are two schemes for configuring and building the software. If -you intend to build the software for only one target system, you -can configure the software so that it is built in the same -directories as the source code. -<div style="margin-left: 2em"> -<pre> -hyla% <b>cd tiff-v3.4beta099</b> -hyla% <b>ls</b> -COPYRIGHT VERSION config.sub dist man -Makefile.in config.guess configure html port -README config.site contrib libtiff tools -hyla% <b>./configure</b> -</pre></div> -<p>Otherwise, you can configure a build tree that is parallel to -the source tree hierarchy but which contains only configured files -and files created during the build procedure.</p> -<div style="margin-left: 2em"> -<pre> -hyla% <b>cd tiff-v3.4beta099</b> -hyla% <b>mkdir obj obj/mycpu</b> -hyla% <b>cd obj/mycpu</b> -hyla% <b>../../configure</b> -</pre></div> -This second scheme is useful for: -<ul> -<li>building multiple targets from a single source tree</li> -<li>building from a read-only source tree (e.g. if you receive the -distribution on CD-ROM)</li> -</ul> -<a name="ConfigOptions" id="ConfigOptions"></a> -<hr width="65%" align="right"> -<h3>Configuration Options</h3> -The configuration process is critical to the proper compilation, -installation, and operation of the software. The configure script -runs a series of tests to decide whether or not the target system -supports required functionality and, if it does not, whether it can -emulate or workaround the missing functions. This procedure is -fairly complicated and, due to the nonstandard nature of most UNIX -systems, prone to error. The first time that you configure the -software for use you should check the output from the configure -script and look for anything that does not make sense for your -system. -<p>A second function of the configure script is to set the default -configuration parameters for the software. Of particular note are -the directories where the software is to be installed. By default -the software is installed in the <b>/usr/local</b> hierarchy. To -change this behaviour the appropriate parameters can be specified -on the command line to configure. Run <b>./configure --help</b> to -get a list of possible options. Installation related options are -shown below.</p> -<pre> -<tt> -Installation directories: - --prefix=PREFIX install architecture-independent files in PREFIX - [/usr/local] - --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX - [PREFIX] - -By default, `make install' will install all the files in -`/usr/local/bin', `/usr/local/lib' etc. You can specify -an installation prefix other than `/usr/local' using `--prefix', -for instance `--prefix=$HOME'. - -For better control, use the options below. - -Fine tuning of the installation directories: - --bindir=DIR user executables [EPREFIX/bin] - --sbindir=DIR system admin executables [EPREFIX/sbin] - --libexecdir=DIR program executables [EPREFIX/libexec] - --datadir=DIR read-only architecture-independent data [PREFIX/share] - --sysconfdir=DIR read-only single-machine data [PREFIX/etc] - --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] - --localstatedir=DIR modifiable single-machine data [PREFIX/var] - --libdir=DIR object code libraries [EPREFIX/lib] - --includedir=DIR C header files [PREFIX/include] - --oldincludedir=DIR C header files for non-gcc [/usr/include] - --infodir=DIR info documentation [PREFIX/info] - --mandir=DIR man documentation [PREFIX/man] - -Program names: - --program-prefix=PREFIX prepend PREFIX to installed program names - --program-suffix=SUFFIX append SUFFIX to installed program names - --program-transform-name=PROGRAM run sed PROGRAM on installed program names -</tt> -</pre> -<a name="Packages" id="Packages"></a> -<hr width="65%" align="right"> -<h3>Configuring Optional Packages/Support</h3> -The TIFF software comes with several packages that are installed -only as needed, or only if specifically configured at the time the -configure script is run. Packages can be configured via the -<b>configure</b> script commandline parameters. -<dl> -<dt><i>Static/Shared Objects Support</i></dt> -<dd><tt>--enable-shared[=PKGS] build shared -libraries [default=yes]<br> ---enable-static[=PKGS] build static -libraries [default=yes]</tt> -<p>These options control whether or not to configure the software -to build a shared and static binaries for the TIFF library. Use of -shared libraries can significantly reduce the disk space needed for -users of the TIFF software. If shared libarries are not used then -the code is statically linked into each application that uses it. -By default both types of binaries is configured.</p> -<p><tt>--enable-rpath Enable runtime linker -paths (-R libtool option)</tt></p> -<p>Add library directories (see other options below) to the TIFF -library run-time linker path.</p> -</dd> -<dt><i>JPEG Support</i></dt> -<dd><tt>--disable-jpeg disable IJG JPEG -library usage (required for JPEG compression, enabled by default) ---with-jpeg-include-dir=DIR location of IJG -JPEG library headers ---with-jpeg-lib-dir=DIR location of IJG JPEG -library binary)</tt></dd> -<dd>The <tt>JPEG</tt> package enables support for the handling of -TIFF images with JPEG-encoded data. Support for JPEG-encoded data -requires the Independent JPEG Group (IJG) <tt>libjpeg</tt> -distribution; this software is available at <a href= -"ftp://ftp.uu.net/graphics/jpeg/">ftp.uu.net:/graphics/jpeg/</a>. -<b>configure</b> script automatically tries to search the working -IJG JPEG installation. If it fails to find library, JPEG support -will be automatically disabled.If you want specify the exact paths -to library binary and headers, use above switches for that.</dd> -<dt><i>ZIP Support</i></dt> -<dd>The <tt>ZIP</tt> support enables support for the handling of -TIFF images with deflate-encoded data. Support for deflate-encoded -data requires the freely available <tt>zlib</tt> distribution -written by Jean-loup Gailly and Mark Adler; this software is -available at <a href= -"ftp://ftp.uu.net/pub/archiving/zip/zlib/">ftp.uu.net:/pub/archiving/zip/zlib/</a> -(or try <a href= -"ftp://quest.jpl.nasa.gov/beta/zlib/">quest.jpl.nasa.gov:/beta/zlib/</a>). -If ZIP support is enabled the <tt>DIRS_LIBINC</tt> and -<tt>DIR_GZLIB</tt> parameters should also be set (see below). By -default this package is not configured.</dd> -</dl> -<a name="Sample" id="Sample"></a> -<hr width="65%" align="right"> -<h3>A Sample Configuration Session</h3> -This section shows a sample configuration session and describes the -work done. The session is shown indented in a <tt>fixed width -font</tt> with user-supplied input in a <tt><b>bold font</b></tt>. -Comments are shown in a normal or <i>italic</i> font. This session -was collected on a 486 machine running BSDI 1.1. -<div style="margin-left: 2em"> -<pre> -<tt> -wullbrandt% <b>mkdir tiff</b> -wullbrandt% <b>cd tiff</b> -wullbrandt% <b>ln -s /hosts/oxford/usr/people/sam/tiff src</b> -</tt> -</pre></div> -A build tree separate from the source tree is used here. In fact, -in this case the distribution is accessed from a read-only -NFS-mounted filesystem. -<div style="margin-left: 2em"> -<pre> -<tt> -wullbrandt% <b>src/configure</b> -Configuring TIFF Software v3.4beta015. - -Reading site-wide parameters from ../tiff-v3.4beta015/config.site. -Reading local parameters from config.local. -Gosh, aren't you lucky to have a i386-unknown-bsdi1.1 system! -</tt> -</pre></div> -Note that configure announces the distribution version and the -deduced target configuration (<tt>i386-unknown-bsdi1.1</tt> here). -<div style="margin-left: 2em"> -<pre> -<tt> -Using /usr/local/bin/gcc for a C compiler (set CC to override). -Looks like /usr/local/bin/gcc supports the -g option. -Using " -g" for C compiler options. -</tt> -</pre></div> -configure checked the normal shell search path for potential ANSI C -compilers. The compiler is selected according to it properly -compiling a small ANSI C test program. A specific compiler may be -requested by setting the <tt>CC</tt> environment variable to the -appropriate pathname, by supplying the parameter on the command -line, e.g. <tt>-with-CC=gcc</tt>, or by setting <tt>CC</tt> in a -configuration file. -<p><img src="images/info.gif" align="left" hspace="10"> <em>Note -that an ANSI C compiler is required to build the software. If a C -compiler requires options to enable ANSI C compilation, they can be -specified with the <tt>ENVOPTS</tt> parameter.</em></p> -<p>Once a compiler is selected configure checks to see if the -compiler accepts a -g option to enable the generation of debugging -symbols, and if the compiler includes an ANSI C preprocessor.</p> -<div style="margin-left: 2em"> -<pre> -<tt> -Using /usr/ucb/make to configure the software. -</tt> -</pre></div> -Next various system-specific libraries that may or may not be -needed are checked for (none are needed in this case). If your -system requires a library that is not automatically included it can -be specified by setting the <tt>MACHDEPLIBS</tt> parameter. -<p><i>Creating port.h.</i> The <b>port.h</b> file is included by -all the C code in the library (but not the tools). It includes -definitions for functions and type definitions that are missing -from system include files, <tt>#defines</tt> to enable or disable -system-specific functionality, and other odds and ends.</p> -<div style="margin-left: 2em"> -<pre> -<tt> -Creating libtiff/port.h with necessary definitions. -... using LSB2MSB bit order for your i386 cpu -... using big-endian byte order for your i386 cpu -... configure use of mmap for memory-mapped files -... O_RDONLY is in <fcntl.h> -... using double for promoted floating point parameters -... enabling use of inline functions -Done creating libtiff/port.h. -</tt> -</pre></div> -This file can take a long time to create so configure generates the -file only when it is needed, either because the file does not exist -or because a different target or compiler is to be used. Note that -running "<tt>make distclean</tt>" in the top-level directory of the -build tree will remove the <b>port.h</b> file (along with all the -other files generated by configure). -<p><i>Selecting emulated library functions.</i> Certain library -functions used by the tools are not present on all systems and can -be emulated using other system functionality. configure checks for -the presence of such functions and if they are missing, will -configure emulation code from the <b>port</b> directory to use -instead. Building the TIFF software on unsupported systems may -require adding to the code to the <b>port</b> directory.</p> -<div style="margin-left: 2em"> -<pre> -<tt> -Checking system libraries for functionality to emulate. -Done checking system libraries. -</tt> -</pre></div> -If a routine must be emulated and configure does not automatically -check for it, the routine name can be specified using the -<tt>PORTFUNCS</tt> parameter. To add emulation support for a new -function <tt>foo</tt>, create a file <b>port/foo.c</b> that -contains the emulation code and then set <tt>PORTFUNCS=foo</tt> in -a configuration file or modify the configure script to -automatically check for the missing function. -<div style="margin-left: 2em"> -<pre> -<tt> -Checking for Dynamic Shared Object (DSO) support. -Done checking for DSO support. -</tt> -</pre></div> -If the <tt>DSO</tt> package is enabled (<tt>DSO=auto</tt> or -<tt>DSO=yes</tt>), then configure will verify the system and -compiler are capable of constructing SVR4-style DSO's in the -expected way. Note that while a system may support DSO's the -compiler may not be capable of generating the required -position-independent code and/or the compiler may not pass the -needed options through to the loader. -<p><i>Selecting utility programs.</i> configure locates various -system utility programs that are used during installation of the -software.</p> -<div style="margin-left: 2em"> -<pre> -<tt> -Selecting programs used during installation. -Looks like mv supports the -f option to force a move. -Looks like /bin/ln supports the -s option to create a symbolic link. -Done selecting programs. -</tt> -</pre></div> -<p><i>Selecting default configuration parameters.</i> The remainder -of the work done by configure involves setting up configuration -parameters that control the placement and setup of files during the -installation procedure.</p> -<div style="margin-left: 2em"> -<pre> -<tt> -Selecting default TIFF configuration parameters. - -Looks like manual pages go in /usr/contrib/man. -Looks like manual pages should be installed with bsd-nroff-gzip-0.gz. - -TIFF configuration parameters are: - -[ 1] Directory for tools: /usr/contrib/bin -[ 2] Directory for libraries: /usr/contrib/lib -[ 3] Directory for include files: /usr/contrib/include -[ 4] Directory for manual pages: /usr/contrib/man -[ 5] Manual page installation scheme: bsd-nroff-gzip-0.gz - -Are these ok [yes]? -</tt> -</pre></div> -At this point you can interactively modify any of the displayed -parameters. Hitting a carriage return or typing <tt>yes</tt> will -accept the current parameters. Typing one of the number displayed -along the left hand side causes configure to prompt for a new value -of the specified parameter. Typing anything else causes configure -to prompt for a new value <em>for each parameter</em>. In general -hitting carriage return will accept the current value and typing -anything that is unacceptable will cause a help message to be -displayed. A description of each of the configuration parameters is -given below. -<p>Once acceptable parameters are setup configure will generate all -the files that depend on these parameters. Note that certain files -may or may not be created based on the configuration of optional -packages and/or the functions supported by target system.</p> -<div style="margin-left: 2em"> -<pre> -<tt> -Creating Makefile from ../tiff-v3.4beta015/Makefile.in -Creating libtiff/Makefile from ../tiff-v3.4beta015/libtiff/Makefile.in -Creating man/Makefile from ../tiff-v3.4beta015/man/Makefile.in -Creating tools/Makefile from ../tiff-v3.4beta015/tools/Makefile.in -Creating port/install.sh from ../tiff-v3.4beta015/port/install.sh.in -Done. -</tt> -</pre></div> -<a name="DSOSupport" id="DSOSupport"></a> -<hr> -<h3>Shared Library Support</h3> -It is desirable to make the TIFF library be a shared object on -systems that have support for shared libraries. Unfortunately the -rules to use to build a shared library vary between operating -systems and even compilers. The distributed software includes -support for building a shared version of the library on a number of -different systems. This support is split between rules in the file -<b>libtiff/Makefile.in</b> that construct the shared library and -checks done by the <tt>configure</tt> script to verify that the -expected rules are supported by compilation tools for the target -system. -<p>To add new support for building a shared library both these -files must be updated. In the configure script search for the -section where the autoconfiguration setting of the <tt>DSO</tt> -parameter is handled and add a new case for the target system that -sets the <tt>DSOSUF</tt>, <tt>DSOLD</tt>, <tt>DSOOPTS</tt>, and -<tt>LIBCOPTS</tt> options as appropriate for the system. -<tt>DSOSUF</tt> specifies the filename suffix used for the shared -library (e.g. ``.so'' for Dynamic Shared Objects on most SVR4-based -systems). <tt>DSOLD</tt> specifies the program to use to build the -shared library from a compiled object file; typically ``${LD}'' -though on some systems it is better to use the C compiler directly -so system-dependent options and libraries are automatically -supplied. <tt>DSOOPTS</tt> are options that must be specified to -<tt>DSOLD</tt> when building the shared library. <tt>LIBCOPTS</tt> -are options to pass to the C compiler when constructing a -relocatable object file to include in a shared library; e.g. ``-K -PIC'' on a Sun system. The <tt>DSO</tt> parameter must also be set -to a unique label that identifies the target system and compilation -tools. This label is used to select a target in -<b>libtiff/Makefile.in</b> to do the actual work in building the -shared library. Finally, to complete support for the shared library -added the appropriate rules to <b>libtiff/Makefile.in</b> under the -target specified in the <tt>configure</tt> script. <a name="PC" id= -"PC"></a></p> -<hr> -<h2>Building the Software under Windows 95/98/NT/2000 with MS -VC++</h2> -With Microsoft Visual C++ installed, and properly configured for -commandline use (you will likely need to source VCVARS32.BAT in -AUTOEXEC.bAT or somewhere similar) you should be able to use the -provided <tt>makefile.vc</tt>. -<p>The source package is delivered using Unix line termination -conventions, which work with MSVC but do not work with Windows -'notepad'. If you use unzip from the <a href= -"http://www.info-zip.org/pub/infozip/">Info-Zip</a> package, you -can extract the files using Windows normal line termination -conventions with a command similar to:</p> -<pre> - unzip -aa -a tiff-3.7.4.zip -</pre> -<p>By default libtiff expects that a pre-built zlib and jpeg -library are provided by the user. If this is not the case, then you -may edit libtiff\tiffconf.h using a text editor (e.g. notepad) and -comment out the entries for JPEG_SUPPORT, PIXARLOG_SUPPORT, and -ZIP_SUPPORT. Ignore the comment at the top of the file which says -that it has no influence on the build, because the statement is not -true for Windows. However, by taking this approach, libtiff will -not be able to open some TIFF files.</p> -<p>To build using the provided makefile.vc you may use:</p> -<pre> - C:\tiff-3.7.4> nmake /f makefile.vc clean - C:\tiff-3.7.4> nmake /f makefile.vc - - or (the hard way) - - C:\tiff-3.7.4> cd port - C:\tiff-3.7.4\port> nmake /f makefile.vc clean - C:\tiff-3.7.4\port> nmake /f makefile.vc - C:\tiff-3.7.4> cd ../libtiff - C:\tiff-3.7.4\libtiff> nmake /f makefile.vc clean - C:\tiff-3.7.4\libtiff> nmake /f makefile.vc - C:\tiff-3.7.4\libtiff> cd ..\tools - C:\tiff-3.7.4\tools> nmake /f makefile.vc clean - C:\tiff-3.7.4\tools> nmake /f makefile.vc -</pre> -<p>This will build the library file -<tt>libtiff\libtiff\libtiff.lib</tt>. This can be used in Win32 -programs. You may want to adjust the build options before start -compiling. All parameters contained in the <tt>nmake.opt</tt> -file.This is a plain text file you can open with your favorite text -editor.</p> -<p>The makefile also builds a DLL (libtiff.dll) with an associated -import library (libtiff_i.lib). Any builds using libtiff will need -to include the LIBTIFF\LIBTIFF directory in the include path.</p> -<p>The <tt>libtiff\tools\makefile.vc</tt> should build .exe's for -all the standard TIFF tool programs.</p> -<p><a name="DJGPP" id="DJGPP"></a></p> -<hr> -<h2>Building the Software under MS/DOS with the DJGPP v2 -compiler</h2> -[<i>From the file <b>contrib/dosdjgpp/README</b>.</i>] -<p>The directory <b>contrib/dosdjgpp</b> contains the files -necessary to build the library and tools with the DJGPP v2 compiler -under MSDOS.</p> -<p>All you have to do is copy the files in the directory into the -respective directories and run make. If you want, you can use the -<b>conf.bat</b> script to do that for you, make sure that the file -is stored with MSDOS text EOL-convention (CR/LF), otherwise the -<b>command.com</b> will not do anything.</p> -<p>Note that you probably will not be able to build the library -with the v1.x versions of djgpp, due to two problems. First, the -top makefile calls a sub-make for each directory and you are likely -to run out of memory, since each recursive invocation of a djgpp -v1.x program requires about 130k, to avoid that, you can enter the -directories manually and call make (well, there are only two dirs). -The 2nd problem is that djgpp 1.x doesn't call the coff2exe -(stubify) program when creating an executable. This means that all -programs compiled are not converted to exe and consequently are not -available for calling directly. For the tools directory, you can -just call coff2exe for each program after make finishes, but in the -libtiff directory, a few programs are created during the make -process that have to be called for make to continue (e.g. -mkg3states). Make will probably report an error at each such stage. -To fix that, either add a coff2exe call before each program is -called or call coff2exe manually and rerun make (there 2-3 such -programs). <a name="MacMPW" id="MacMPW"></a></p> -<hr> -<h2>Building the Software on a Macintosh with MPW</h2> -The directory <b>contrib/mac-mpw</b> contains support for compiling -the library and tools under the MPW Shell on a Macintosh system. -This support was contributed by Niles Ritter (<a href= -"mailto:ndr@tazboy.jpl.nasa.gov">ndr@tazboy.jpl.nasa.gov</a>). -<p>[<i>From the file <b>contrib/mac-mpw/README</b>.</i>]</p> -<p>This directory contains all of the utilities and makefile source -to build the LIBTIFF library and tools from the MPW Shell. The file -BUILD.mpw in this directory is an executable script which uses all -of these files to create the MPW makefiles and run them.</p> -<p>The <file>.make files are not MPW makefiles as such, but -are when run through the "mactrans" program, which turns the ascii -"%nn" metacharacters into the standard weird MPW make -characters.</p> -<p>This translation trick is necessary to protect the files when -they are put into unix tarfiles, which tend to mangle the special -characters. <a name="MacCW" id="MacCW"></a></p> -<hr> -<h2>Building the Software on a Macintosh with CodeWarrior</h2> -The directory <b>contrib/mac-cw</b> contains support for compiling -the library and tools with MetroWerks CodeWarrior 6.1 on a -Macintosh system. This support was contributed by Niles Ritter -(<a href= -"mailto:ndr@tazboy.jpl.nasa.gov">ndr@tazboy.jpl.nasa.gov</a>). -<p>[<i>From the file <b>contrib/mac-cw/README</b>.</i>] In this -directory you will find a Makefile.script Applescript file, which -should be run in order to build the libtiff code using MetroWerks -CodeWarrior. Refer to the "metrowerks.note" instructions on -building the library for 68k and PowerPC native code, as well as -building some of the libtiff tools, which are rather unix-like, but -at least give an example of how to link everything together. -<a name="VMS" id="VMS"></a></p> -<hr> -<h2>Building the Software on a VMS System</h2> -The VMS port was done by Karsten Spang (<a href= -"mailto:krs@kampsax.dk">krs@kampsax.dk</a>), who also "sort of" -maintains it. The VMS specific files are not in the main -directories. Instead they are placed under -<tt>[.CONTRIB.VMS...]</tt> in the distribution tree. Installation: -It is assumed that you have unpacked the tar file into a VMS -directory tree, in this text called DISK:[TIFF]. -<ol> -<li>Move the VMS specific files to their proper directories. -<pre> -$ SET DEFAULT DISK:[TIFF.CONTRIB.VMS] -$ RENAME [.LIBTIFF]*.* [-.-.LIBTIFF] -$ RENAME [.TOOLS]*.* [-.-.TOOLS] -</pre></li> -<li>Compile the library. -<pre> -$ SET DEFAULT DISK:[TIFF.LIBTIFF] -$ @MAKEVMS -</pre></li> -<li>Compile the tools. -<pre> -$ SET DEFAULT DISK:[TIFF.TOOLS] -$ @MAKEVMS -</pre></li> -<li>Define the programs. -<pre> -$ DEFINE TIFFSHR DISK:[TIFF.LIBTIFF]TIFFSHR -$ FAX2PS :==$DISK:[TIFF.TOOLS]FAX2PS -$ FAX2TIFF :==$DISK:[TIFF.TOOLS]FAX2TIFF -$ GIF2TIFF :==$DISK:[TIFF.TOOLS]GIF2TIFF -$ PAL2RGB :==$DISK:[TIFF.TOOLS]PAL2RGB -$ PPM2TIFF :==$DISK:[TIFF.TOOLS]PPM2TIFF -$ RAS2TIFF :==$DISK:[TIFF.TOOLS]RAS2TIFF -$ RGB2YCBCR :==$DISK:[TIFF.TOOLS]RGB2YCBCR -$ THUMBNAIL :==$DISK:[TIFF.TOOLS]THUMBNAIL -$ TIFF2BW :==$DISK:[TIFF.TOOLS]TIFF2BW -$ TIFF2PS :==$DISK:[TIFF.TOOLS]TIFF2PS -$ TIFFCMP :==$DISK:[TIFF.TOOLS]TIFFCMP -$ TIFFCP :==$DISK:[TIFF.TOOLS]TIFFCP -$ TIFFDITHER:==$DISK:[TIFF.TOOLS]TIFFDITHER -$ TIFFDUMP :==$DISK:[TIFF.TOOLS]TIFFDUMP -$ TIFFINFO :==$DISK:[TIFF.TOOLS]TIFFINFO -$ TIFFMEDIAN:==$DISK:[TIFF.TOOLS]TIFFMEDIAN -$ TIFFSPLIT :==$DISK:[TIFF.TOOLS]TIFFSPLIT -$ YCBCR :==$DISK:[TIFF.TOOLS]YCBCR -</pre></li> -</ol> -You will want to add these lines to your <tt>LOGIN.COM</tt> file, -after changing the name of the directory that you have used on your -machine. -<p>This release has been tested on OpenVMS/VAX 5.5-2, using VAX C -3.2. A previous release was tested under OpenVMS/AXP ?.? using DEC -C ?.?, it is believed that this release as well works on AXP. The -code contains some GNU C specific things. This does *not* imply, -however, that the VAX/GCC configuration has been tested, *it has -not*.</p> -<p>The command procedures (<tt>MAKEVMS.COM</tt>) for building the -library and tools, is believed to choose the correct options for -the VAX and AXP cases automatically.</p> -<p>On the AXP, IEEE floating point is used by default. If you want -VAX floating point, remove the <tt>/FLOAT=IEEE_FLOAT</tt> -qualifier, and change <tt>HAVE_IEEEFP=1</tt> to -<tt>HAVE_IEEEFP=0</tt> in the <tt>MAKEVMS.COM</tt> files in both -the <b>libtiff</b> and <b>tools</b> directories.</p> -<h3>Compiling your own program on a VMS system:</h3> -When compiling a source file in which you <tt>"#include -<tiffio.h>"</tt>, use the following command -<pre> - $ CC/INCLUDE=DISK:[TIFF.LIBTIFF] -</pre> -This ensures that the header file is found. On the AXP, also add -<tt>/FLOAT=IEEE_FLOAT</tt> (if used when building the library). -<h3>Linking your own program to the TIFF library on a VMS -system:</h3> -You can link to the library in two ways: Either using the shareable -library, or using the object library. On the VAX these -possibilities are: -<ol> -<li>Using the shareable TIFF library. -<pre> -$ LINK MY_PROGRAM,DISK:[TIFF.LIBTIFF]TIFF/OPTIONS,SYS$INPUT:/OPTIONS - SYS$SHARE:VAXCRTL/SHAREABLE -</pre></li> -<li>Using the TIFF object library. -<pre> -$ LINK MY_PROGRAM, - - DISK:[TIFF.LIBTIFF]TIFF/LIBRARY/INCLUDE=(TIF_FAX3SM,TIF_CODEC), - - SYS$INPUT:/OPTIONS - SYS$SHARE:VAXCRTL/SHAREABLE -</pre></li> -</ol> -On AXP (and possibly also using DEC C on VAX) the corresponding -commands are -<ol> -<li>Using the shareable TIFF library. -<pre> -$ LINK MY_PROGRAM,DISK:[TIFF.LIBTIFF]TIFF/OPTIONS -</pre></li> -<li>Using the TIFF object library. -<pre> -$ LINK MY_PROGRAM,DISK:[TIFF.LIBTIFF]TIFF/LIBRARY -</pre></li> -</ol> -Method 1 uses the shortest link time and smallest <tt>.EXE</tt> -files, but it requires that <tt>TIFFSHR</tt> is defined as above at -link time and <strong>at run time</strong>. Using the compilation -procedure above, the tools are linked in this way. -<p>Method 2 gives somewhat longer link time and larger -<tt>.EXE</tt> files, but does not require <tt>TIFFSHR</tt> to be -defined. This method is recommended if you want to run your program -on another machine, and for some reason don't want to have the -library on that machine. If you plan to have more than one program -(including the tools) on the machine, it is recommended that you -copy the library to the other machine and use method 1. <a name= -"Acorn" id="Acorn"></a></p> -<hr> -<h2>Building the Software on an Acorn RISC OS system</h2> -The directory <b>contrib/acorn</b> contains support for compiling -the library under Acorn C/C++ under Acorn's RISC OS 3.10 or above. -Subsequent pathnames will use the Acorn format: The full-stop or -period character is a pathname delimeter, and the slash character -is not interpreted; the reverse position from Unix. Thus -"libtiff/tif_acorn.c" becomes "libtiff.tif_acorn/c". -<p>This support was contributed by Peter Greenham. (<a href= -"mailto:peter@enlarion.demon.co.uk">peter@enlarion.demon.co.uk</a>).</p> -<h3>Installing LibTIFF:</h3> -<p>LIBTIFF uses several files which have names longer than the -normal RISC OS maximum of ten characters. This complicates matters. -Maybe one day Acorn will address the problem and implement long -filenames properly. Until then this gets messy, especially as I'm -trying to do this with obeyfiles and not have to include binaries -in this distribution.</p> -<p>First of all, ensure you have Truncate configured on (type -<tt>*Configure Truncate On</tt>)</p> -<p>Although it is, of course, preferable to have long filenames, -LIBTIFF can be installed with short filenames, and it will compile -and link without problems. However, <i>getting</i> it there is more -problematic. <b>contrib.acorn.install</b> is an installation -obeyfile which will create a normal Acorn-style library from the -source (ie: with c, h and o folders etc.), but needs the -distribution library to have been unpacked into a location which is -capable of supporting long filenames, even if only temporarily.</p> -<p>My recommendation, until Acorn address this problem properly, is -to use Jason Tribbeck's <a href= -"ftp://ftp.demon.co.uk/pub/mirrors/hensa/micros/arch/riscos/c/c020/longfiles.arc"> -LongFilenames</a>, or any other working system that gives you long -filenames, like a nearby NFS server for instance.</p> -<p>If you are using Longfilenames, even if only temporarily to -install LIBTIFF, unpack the TAR into a RAMDisc which has been -longfilenamed (ie: <tt>*addlongfs ram</tt>) and then install from -there to the hard disk. Unfortunately Longfilenames seems a bit -unhappy about copying a bunch of long-named files across the same -filing system, but is happy going between systems. You'll need to -create a ramdisk of about 2Mb.</p> -<p>Now you can run the installation script I've supplied (in -contrib.acorn), which will automate the process of installing -LIBTIFF as an Acorn-style library. The syntax is as follows:</p> -<p><tt>install <source_dir> <dest_dir></tt></p> -<p>Install will then create <dest_dir> and put the library in -there. For example, having used LongFilenames on the RAMDisk and -unpacked the library into there, you can then type:</p> -<p><tt>Obey RAM::RamDisc0.$.contrib.acorn.install RAM::RamDisc0.$ -ADFS::4.$.LIBTIFF</tt></p> -<p>It doesn't matter if the destination location can cope with long -filenames or not. The filenames will be truncated if necessary -(*Configure Truncate On if you get errors) and all will be -well.</p> -<h3>Compiling LibTIFF:</h3> -<p>Once the LibTIFF folder has been created and the files put -inside, making the library should be just a matter of running -'<b>SetVars</b>' to set the appropriate system variables, then -running '<b>Makefile</b>'.</p> -<p><b>OSLib</b></p> -<p><a href= -"ftp://ftp.acorn.co.uk/pub/riscos/releases/oslib/oslib.arc">OSLib</a> -is a comprehensive API for RISC OS machines, written by Jonathan -Coxhead of Acorn Computers (although OSLib is not an official Acorn -product). Using the OSLib SWI veneers produces code which is more -compact and more efficient than code written using _kernel_swi or -_swi. The Acorn port of LibTIFF can take advantage of this if -present. Edit the Makefile and go to the Static dependencies -section. The first entry is:</p> -<pre> -# Static dependencies: -@.o.tif_acorn: @.c.tif_acorn - cc $(ccflags) -o @.o.tif_acorn @.c.tif_acorn -</pre> -<p>Change the cc line to:</p> -<pre> - cc $(ccflags) -DINCLUDE_OSLIB -o @.o.tif_acorn @.c.tif_acorn -</pre> -<p>Remember, however, that OSLib is only <i>recommended</i> for -efficiency's sake. It is not required. <a name="Other" id= -"Other"></a></p> -<hr> -<h2>Building the Software on Other Systems</h2> -This section contains information that might be useful if you are -working on a non-UNIX system that is not directly supported. All -library-related files described below are located in the -<b>libtiff</b> directory. -<p>The library requires two files that are generated -<i>on-the-fly</i>. The file <b>tif_fax3sm.c</b> has the state -tables for the Group 3 and Group 4 decoders. This file is generated -by the <tt>mkg3states</tt> program on a UNIX system; for -example,</p> -<div style="margin-left: 2em"> -<pre> -<tt> -cd libtiff -cc -o mkg3states mkg3states.c -rm -f tif_fax3sm.c -./mkg3states -c const tif_fax3sm.c -</tt> -</pre></div> -The <tt>-c</tt> option can be used to control whether or not the -resutling tables are generated with a <tt>const</tt> declaration. -The <tt>-s</tt> option can be used to specify a C storage class for -the table declarations. The <tt>-b</tt> option can be used to force -data values to be explicitly bracketed with ``{}'' (apparently -needed for some MS-Windows compilers); otherwise the structures are -emitted in as compact a format as possible. Consult the source code -for this program if you have questions. -<p>The second file required to build the library, <b>version.h</b>, -contains the version information returned by the -<tt>TIFFGetVersion</tt> routine. This file is built on most systems -using the <tt>mkversion</tt> program and the contents of the -<tt>VERSION</tt> and <tt>tiff.alpha</tt> files; for example,</p> -<div style="margin-left: 2em"> -<pre> -cd libtiff -cc -o mkversion mkversion.c -rm -f version.h -./mkversion -v ../VERSION -a ../dist/tiff.alpha version.h -</pre></div> -<p>Otherwise, when building the library on a non-UNIX system be -sure to consult the files <b>tiffcomp.h</b> and <b>tiffconf.h</b>. -The former contains system compatibility definitions while the -latter is provided so that the software configuration can be -controlled on systems that do not support the make facility for -building the software.</p> -<p>Systems without a 32-bit compiler may not be able to handle some -of the codecs in the library; especially the Group 3 and 4 decoder. -If you encounter problems try disabling support for a particular -codec; consult the <a href= -"internals.html#Config">documentation</a>.</p> -<p>Programs in the tools directory are written to assume an ANSI C -compilation environment. There may be a few POSIX'isms as well. The -code in the <b>port</b> directory is provided to emulate routines -that may be missing on some systems. On UNIX systems the -<tt>configure</tt> script automatically figures out which routines -are not present on a system and enables the use of the equivalent -emulation routines from the <b>port</b> directory. It may be -necessary to manually do this work on a non-UNIX system. <a name= -"Testing" id="Testing"></a></p> -<hr> -<h2>Checking out the Software</h2> -<p>Assuming you have working versions of <tt>tiffgt</tt> and -<tt>tiffsv</tt>, you can just use them to view any of the sample -images available for testing (see the <a href="images.html">section -on obtaining the test images</a>). Otherwise, you can do a cursory -check of the library with the <tt>tiffcp</tt> and <tt>tiffcmp</tt> -programs. For example,</p> -<div style="margin-left: 2em"> -<pre> -tiffcp -lzw cramps.tif x.tif -tiffcmp cramps.tif x.tif -</pre></div> -<p>(<tt>tiffcmp</tt> should be silent if the files compare -correctly). <a name="TOC" id="TOC"></a></p> -<hr> -<h2>Table of Contents</h2> -The following files makup the core library: -<pre> -libtiff/tiff.h TIFF spec definitions -libtiff/tiffcomp.h non-UNIX OS-compatibility definitions -libtiff/tiffconf.h non-UNIX configuration definitions -libtiff/tiffio.h public TIFF library definitions -libtiff/tiffiop.h private TIFF library definitions -libtiff/t4.h CCITT Group 3/4 code tables+definitions -libtiff/tif_dir.h private defs for TIFF directory handling -libtiff/tif_fax3.h CCITT Group 3/4-related definitions -libtiff/tif_predict.h private defs for Predictor tag support -libtiff/uvcode.h LogL/LogLuv codec-specific definitions -libtiff/version.h version string (generated by Makefile) - -libtiff/tif_acorn.c Acorn-related OS support -libtiff/tif_apple.c Apple-related OS support -libtiff/tif_atari.c Atari-related OS support -libtiff/tif_aux.c auxilary directory-related functions -libtiff/tif_close.c close an open TIFF file -libtiff/tif_codec.c configuration table of builtin codecs -libtiff/tif_compress.c compression scheme support -libtiff/tif_dir.c directory tag interface code -libtiff/tif_dirinfo.c directory known tag support code -libtiff/tif_dirread.c directory reading code -libtiff/tif_dirwrite.c directory writing code -libtiff/tif_dumpmode.c "no" compression codec -libtiff/tif_error.c library error handler -libtiff/tif_fax3.c CCITT Group 3 and 4 codec -libtiff/tif_fax3sm.c G3/G4 state tables (generated by mkg3states) -libtiff/tif_flush.c i/o and directory state flushing -libtiff/tif_getimage.c TIFFRGBAImage support -libtiff/tif_jpeg.c JPEG codec (interface to the IJG distribution) -libtiff/tif_luv.c SGI LogL/LogLuv codec -libtiff/tif_lzw.c LZW codec -libtiff/tif_msdos.c MSDOS-related OS support -libtiff/tif_next.c NeXT 2-bit scheme codec (decoding only) -libtiff/tif_open.c open and simply query code -libtiff/tif_packbits.c Packbits codec -libtiff/tif_pixarlog.c Pixar codec -libtiff/tif_predict.c Predictor tag support -libtiff/tif_print.c directory printing support -libtiff/tif_read.c image data reading support -libtiff/tif_strip.c some strip-related code -libtiff/tif_swab.c byte and bit swapping support -libtiff/tif_thunder.c Thunderscan codec (decoding only) -libtiff/tif_tile.c some tile-related code -libtiff/tif_unix.c UNIX-related OS support -libtiff/tif_version.c library version support -libtiff/tif_vms.c VMS-related OS support -libtiff/tif_warning.c library warning handler -libtiff/tif_win3.c Windows-3.1-related OS support -libtiff/tif_win32.c Win32 (95/98/NT) related OS support -libtiff/tif_write.c image data writing support -libtiff/tif_zip.c Deflate codec - -libtiff/mkg3states.c program to generate G3/G4 decoder state tables -libtiff/mkspans.c program to generate black-white span tables -libtiff/mkversion.c program to generate libtiff/version.h. -</pre> -<hr> -Last updated: $Date: 2005/12/24 22:25:05 $ -</body> -</html> diff --git a/src/3rdparty/libtiff/html/contrib.html b/src/3rdparty/libtiff/html/contrib.html deleted file mode 100644 index d138900..0000000 --- a/src/3rdparty/libtiff/html/contrib.html +++ /dev/null @@ -1,209 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Contributed TIFF Software -</TITLE> -</HEAD> - -<BODY BGCOLOR=white> -<FONT FACE="Arial, Helvetica, Sans"> -<H1> -<IMG SRC=images/smallliz.jpg WIDTH=144 HEIGHT=108 ALIGN=left BORDER=1 HSPACE=6> -Contributed TIFF Software -</H1> - - -<P> -The <B>contrib</B> directory has contributed software that -uses the TIFF library or which is associated with the library -(typically glue and guidance for ports to non-UNIX platforms, or tools that -aren't directly TIFF related). - -<BR CLEAR=left> - -<P> -<TABLE BORDER CELLPADDING=3> - -<TR> -<TD VALIGN=top> -<B>contrib/vms</B> -</TD> -<TD> -scripts and files from Karsten Spang for building - the library and tools under VMS -</TD> -</TR> - -<TR> -<TD VALIGN=top> -<B>contrib/dbs</B> -</TD> -<TD> -various tools from Dan & Chris Sears, including a simple X-based viewer -</TD> -</TR> - -<TR> -<TD VALIGN=top> -<B>contrib/ras</B> -</TD> -<TD> -two programs by Patrick Naughton for converting - between Sun rasterfile format and TIFF (these - require <TT>libpixrect.a</TT>, as opposed to the one in - tools that doesn't) -</TD> -</TR> - -<TR> -<TD VALIGN=top> -<B>contrib/mac-mpw</B><br> -<B>contrib/mac-cw</B> -</TD> -<TD> -scripts and files from Niles Ritter for building -the library and tools under Macintosh/MPW C and -code warrior. -</TD> -</TR> - -<TR> -<TD VALIGN=top> -<B>contrib/acorn</B> -</TD> -<TD> -scripts and files from Peter Greenham for building - the library and tools on an Acorn RISC OS system. -</TD> -</TR> - -<TR> -<TD VALIGN=top> -<B>contrib/win32</B> -</TD> -<TD> -scripts and files from Scott Wagner for building -the library under Windows NT and Windows 95. (The makefile.vc in the -libtiff/libtiff directory may be sufficient for most users.) -</TD> -</TR> - -<TR> -<TD VALIGN=top> -<B>contrib/win_dib</B> -</TD> -<TD> -two separate implementations of TIFF to DIB code suitable for any Win32 -platform. Contributed by Mark James, and Philippe Tenenhaus. -</TD> -</TR> - -<TR> -<TD VALIGN=top> -<B>contrib/ojpeg</B> -</TD> -<TD> -Patch for IJG JPEG library related to support for some Old JPEG in TIFF files. -Contributed by Scott Marovich. -</TD> -</TR> - -<TR> -<TD VALIGN=top> -<B>contrib/dosdjgpp</B> -</TD> -<TD> -scripts and files from Alexander Lehmann for building - the library under MSDOS with the DJGPP v2 compiler. -</TD> -</TR> - -<TR> -<TD VALIGN=top> -<B>contrib/tags</B> -</TD> -<TD> -scripts and files from Niles Ritter for adding private - tag support at runtime, without changing libtiff. -</TD> -</TR> - -<TR> -<TD VALIGN=top> -<B>contrib/mfs</B> -</TD> -<TD> -code from Mike Johnson to read+write images in memory -without modifying the library -</TD> -</TR> - -<TR> -<TD VALIGN=top> -<B>contrib/pds</B> -</TD> -<TD> -various routines from Conrad Poelman; a TIFF image iterator and - code to support ``private sub-directories'' -</TD> -</TR> - -<TR> -<TD VALIGN=top> -<B>contrib/iptcutil</B> -</TD> - -<TD> - -A utility by <A HREF=mailto:billr@corbis.com>Bill Radcliffe</a> to -convert an extracted IPTC Newsphoto caption from a binary blob to -ASCII text, and vice versa. IPTC binary blobs can be extracted from -images via the <A -HREF=http://www.ImageMagick.org/>ImageMagick</a> convert(1) -utility. - - -</TD> -</TR> - -<TR> -<TD VALIGN=top> -<B>contrib/addtiffo</B> -</TD> - -<TD> - -A utility (and supporting subroutine) for building -one or more reduce resolution -overviews to an existing TIFF file. Supplied by -<a href="http://pobox.com/~warmerdam">Frank Warmerdam</a>. - -</TD> -</TR> - -<TR> -<TD VALIGN=top> -<B>contrib/stream</B> -</TD> - -<TD> - -A class (TiffStream) for accessing TIFF files through a C++ stream -interface. Supplied by <a href="mailto:avi@shutterfly.com">Avi Bleiweiss</a>. - -</TD> -</TR> - -</TABLE> - -<P> -Questions regarding these packages are usually best directed toward -their authors. - -<P> -<HR> - -Last updated: $Date: 2006/01/03 01:42:30 $ - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/document.html b/src/3rdparty/libtiff/html/document.html deleted file mode 100644 index 12f138f..0000000 --- a/src/3rdparty/libtiff/html/document.html +++ /dev/null @@ -1,48 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -TIFF Documentation -</TITLE> -</HEAD> -<BODY BGCOLOR=white> -<FONT FACE="Arial, Helvetica, Sans"> -<H1> -<IMG SRC=images/jim.gif WIDTH=139 HEIGHT=170 ALIGN=left BORDER=1 HSPACE=6> -TIFF Documentation -</H1> - -<P> -A copy of the 6.0 specification is available from Adobe at -<A HREF="http://partners.adobe.com/public/developer/en/tiff/TIFF6.pdf">http://partners.adobe.com/public/developer/en/tiff/TIFF6.pdf</A>, or from the libtiff -ftp site at <a href="ftp://ftp.remotesensing.org/pub/libtiff/doc/TIFF6.pdf"> -ftp://ftp.remotesensing.org/pub/libtiff/doc/TIFF6.pdf</A>.<p> - -<P> -Draft <a href="TIFFTechNote2.html">TIFF Technical Note #2</A> covers problems -with the TIFF 6.0 design for embedding JPEG-compressed data in TIFF, and -describes an alternative. <p> - -Other Adobe information on TIFF can be retrieved from: - -<A HREF="http://partners.adobe.com/public/developer/tiff/index.html"> -http://partners.adobe.com/public/developer/tiff/index.html</A> - -<P> -Joris Van Damme maintains a list of known tags and their descriptions and -definitions. It is available online at -<A HREF="http://www.awaresystems.be/imaging/tiff/tifftags.html"> -http://www.awaresystems.be/imaging/tiff/tifftags.html</A> - -<P> -There is a FAQ, related both to TIFF format and libtiff library: -<A HREF="http://www.awaresystems.be/imaging/tiff/faq.html"> -http://www.awaresystems.be/imaging/tiff/faq.html</A> - -<HR> - -<ADDRESS> - Last updated: $Date: 2009-08-20 22:31:00 $ -</ADDRESS> - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/images.html b/src/3rdparty/libtiff/html/images.html deleted file mode 100644 index 150ed0c..0000000 --- a/src/3rdparty/libtiff/html/images.html +++ /dev/null @@ -1,41 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -TIFF Test Images -</TITLE> -</HEAD> -<BODY BGCOLOR=white> -<FONT FACE="Arial, Helvetica, Sans"> -<H1> -<IMG SRC=images/bali.jpg WIDTH=158 HEIGHT=107 ALIGN=left BORDER=1 HSPACE=6> -TIFF Test Images -</H1> - -<P> -Test images are available for most formats supported by the library. -Most of the images included in the test kit are also part of this -documentation (albeit in TIFF rather than GIF or JFIF). -The images are kept in a separate archive that should be located in -the same directory as this software. - -<BR CLEAR=left> - -<P> -The latest archive of test images is located at -<A HREF="ftp://ftp.remotesensing.org/pub/libtiff/pics-3.8.0.tar.gz"> -ftp://ftp.remotesensing.org/pub/libtiff/pics-3.8.0.tar.gz</A> - -<P> -There are two other good sources for TIFF test images: -the contributed software <B>contrib/dbs</B> includes several -programs that generate test images suitable for debugging, and -the <TT>tiffcp</TT> program can be used to generate a variety -of images with different storage characteristics. - -<P> -<HR> - -Last updated: $Date: 2006/01/02 23:50:44 $ - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/images/back.gif b/src/3rdparty/libtiff/html/images/back.gif Binary files differdeleted file mode 100644 index 11d0c35..0000000 --- a/src/3rdparty/libtiff/html/images/back.gif +++ /dev/null diff --git a/src/3rdparty/libtiff/html/images/bali.jpg b/src/3rdparty/libtiff/html/images/bali.jpg Binary files differdeleted file mode 100644 index 1f5c146..0000000 --- a/src/3rdparty/libtiff/html/images/bali.jpg +++ /dev/null diff --git a/src/3rdparty/libtiff/html/images/cat.gif b/src/3rdparty/libtiff/html/images/cat.gif Binary files differdeleted file mode 100644 index 5bd3fac..0000000 --- a/src/3rdparty/libtiff/html/images/cat.gif +++ /dev/null diff --git a/src/3rdparty/libtiff/html/images/cover.jpg b/src/3rdparty/libtiff/html/images/cover.jpg Binary files differdeleted file mode 100644 index 8698cfb..0000000 --- a/src/3rdparty/libtiff/html/images/cover.jpg +++ /dev/null diff --git a/src/3rdparty/libtiff/html/images/cramps.gif b/src/3rdparty/libtiff/html/images/cramps.gif Binary files differdeleted file mode 100644 index 9153f9a..0000000 --- a/src/3rdparty/libtiff/html/images/cramps.gif +++ /dev/null diff --git a/src/3rdparty/libtiff/html/images/dave.gif b/src/3rdparty/libtiff/html/images/dave.gif Binary files differdeleted file mode 100644 index c36d447..0000000 --- a/src/3rdparty/libtiff/html/images/dave.gif +++ /dev/null diff --git a/src/3rdparty/libtiff/html/images/info.gif b/src/3rdparty/libtiff/html/images/info.gif Binary files differdeleted file mode 100644 index 783d631..0000000 --- a/src/3rdparty/libtiff/html/images/info.gif +++ /dev/null diff --git a/src/3rdparty/libtiff/html/images/jello.jpg b/src/3rdparty/libtiff/html/images/jello.jpg Binary files differdeleted file mode 100644 index df99e66..0000000 --- a/src/3rdparty/libtiff/html/images/jello.jpg +++ /dev/null diff --git a/src/3rdparty/libtiff/html/images/jim.gif b/src/3rdparty/libtiff/html/images/jim.gif Binary files differdeleted file mode 100644 index 9a18a03..0000000 --- a/src/3rdparty/libtiff/html/images/jim.gif +++ /dev/null diff --git a/src/3rdparty/libtiff/html/images/note.gif b/src/3rdparty/libtiff/html/images/note.gif Binary files differdeleted file mode 100644 index 7177d68..0000000 --- a/src/3rdparty/libtiff/html/images/note.gif +++ /dev/null diff --git a/src/3rdparty/libtiff/html/images/oxford.gif b/src/3rdparty/libtiff/html/images/oxford.gif Binary files differdeleted file mode 100644 index dd4b86e..0000000 --- a/src/3rdparty/libtiff/html/images/oxford.gif +++ /dev/null diff --git a/src/3rdparty/libtiff/html/images/quad.jpg b/src/3rdparty/libtiff/html/images/quad.jpg Binary files differdeleted file mode 100644 index 4b7df17..0000000 --- a/src/3rdparty/libtiff/html/images/quad.jpg +++ /dev/null diff --git a/src/3rdparty/libtiff/html/images/ring.gif b/src/3rdparty/libtiff/html/images/ring.gif Binary files differdeleted file mode 100644 index 2a614f4..0000000 --- a/src/3rdparty/libtiff/html/images/ring.gif +++ /dev/null diff --git a/src/3rdparty/libtiff/html/images/smallliz.jpg b/src/3rdparty/libtiff/html/images/smallliz.jpg Binary files differdeleted file mode 100644 index 8eb827f..0000000 --- a/src/3rdparty/libtiff/html/images/smallliz.jpg +++ /dev/null diff --git a/src/3rdparty/libtiff/html/images/strike.gif b/src/3rdparty/libtiff/html/images/strike.gif Binary files differdeleted file mode 100644 index 0709d19..0000000 --- a/src/3rdparty/libtiff/html/images/strike.gif +++ /dev/null diff --git a/src/3rdparty/libtiff/html/images/warning.gif b/src/3rdparty/libtiff/html/images/warning.gif Binary files differdeleted file mode 100644 index f51eb4b..0000000 --- a/src/3rdparty/libtiff/html/images/warning.gif +++ /dev/null diff --git a/src/3rdparty/libtiff/html/index.html b/src/3rdparty/libtiff/html/index.html deleted file mode 100644 index e43a708..0000000 --- a/src/3rdparty/libtiff/html/index.html +++ /dev/null @@ -1,123 +0,0 @@ -<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html lang="en"> -<head> - <title>LibTIFF - TIFF Library and Utilities</title> - <meta http-equiv="content-type" content="text/html; charset=ISO-8859-1"> - <meta http-equiv="content-language" content="en"> - <style type="text/css"> - <!-- - th {text-align: left; vertical-align: top; padding-right: 1em; white-space: nowrap} - --> - </style> -</head> -<body lang="en" text="#000000" bgcolor="#ffffff" link="#0000ff" alink="#0000ff" vlink="#0000ff"> - <h1>LibTIFF - TIFF Library and Utilities</h1> - <hr> - <table cellspacing="0" cellpadding="0" border="0"> - <tr> - <th>Home Page</th> - <td><a href="http://www.remotesensing.org/libtiff/" title="Home of the LibTIFF software">http://www.remotesensing.org/libtiff/</a></td> - </tr> - <tr> - <th>Home Page Mirror</th> - <td><a href="http://libtiff.maptools.org/" title="Mirror of the LibTIFF software">http://libtiff.maptools.org/</a></td> - </tr> - <tr> - <th>Latest Stable Release</th> - <td><a href="v3.9.2.html">v3.9.2</a></td> - </tr> - <tr> - <th>Master Download Site</th> - <td><a href="ftp://ftp.remotesensing.org/pub/libtiff">ftp.remotesensing.org</a>, directory pub/libtiff</td> - </tr> - <tr> - <th>Mirror Download Site</th> - <td><a href="http://libtiff.maptools.org/dl/">http://libtiff.maptools.org/dl/</a></td> - </tr> - <tr> - <th>Windows Binaries</th> - <td><a href="http://gnuwin32.sourceforge.net/packages/libtiff.htm">GnuWin32 Project</a></td> - </tr> - <tr> - <th>Mailing List</th> - <td><a href="mailto:tiff@lists.maptools.org">tiff@lists.maptools.org</a>, - <a href="http://lists.maptools.org/mailman/listinfo/tiff/">Subscription</a>, - <a href="http://www.awaresystems.be/imaging/tiff/tml.html">Archive</a>. - Please, read the <a href="http://www.awaresystems.be/imaging/tiff/faq.html">TIFF FAQ</a> - before asking questions.</td> - </tr> - <tr> - <th>Anonymous CVS</th> - <td><tt>export CVSROOT=:pserver:cvsanon@cvs.maptools.org:/cvs/maptools/cvsroot<br> - cvs login</tt><br> - (use empty password)<br> - <tt>cvs checkout -r branch-3-9 libtiff<br></tt> - to get stable libtiff branch, or<br> - <tt>cvs checkout libtiff</tt><br> - to get bleeding edge development version of libtiff from CVS HEAD.</td> - </tr> - </table> - <hr> - <p> - This software provides support for the <i>Tag Image File Format</i> (TIFF), - a widely used format for storing image data. The latest version of - the TIFF specification is <a href="document.html">available on-line</a> - in several different formats. - </p> - <p> - Included in this software distribution is a library, libtiff, for reading - and writing TIFF, a small collection of tools for doing simple - manipulations of TIFF images, and documentation on the - library and tools. Libtiff is a portable software, it was built and - tested on various systems: UNIX flavors (Linux, BSD, Solaris, MacOS X), - Windows, OpenVMS. It should be possible to port libtiff and additional - tools on other OSes. - </p> - <p> - The library, along with associated tool programs, should handle most of - your needs for reading and writing TIFF images on 32- and 64-bit - machines. This software can also be used on older 16-bit systems - though it may require some effort and you may need to leave out some of - the compression support. - </p> - <p> - The software was originally authored and maintained by Sam Leffler. - While he keeps a fatherly eye on the mailing list, he is no longer - responsible for day to day maintenance. - </p> - <p> - Questions should be sent to the TIFF mailing list: - <a href="mailto:tiff@lists.maptools.org">tiff@lists.maptools.org</a>, with - a subscription interface at - <a href="http://lists.maptools.org/mailman/listinfo/tiff">http://lists.maptools.org/mailman/listinfo/tiff</a>. - </p> - <p> - The persons responsible for putting up this site and putting together - versions >= 3.5.1 are - <a href="http://pobox.com/~warmerdam">Frank Warmerdam</a>, - <a href="mailto:dron@ak4719.spb.edu">Andrey Kiselev</a>, Bob Friesenhahn, -Joris Van Damme and Lee Howard. - </p> - <p> - The following sections are included in this documentation: - </p> - <ul> - <li><a href="support.html">TIFF 6.0 specification coverage</a></li> - <li><a href="libtiff.html">Using the TIFF Library</a></li> - <li><a href="internals.html">Modifying the TIFF Library</a> - and <a href="addingtags.html">Adding New Tags</a></li> - <li><a href="tools.html">TIFF tools overview</a></li> - <li><a href="contrib.html">Contributed software</a></li> - <li><a href="document.html">TIFF documentation</a></li> - <li><a href="build.html">Building the software distribution</a></li> - <li><a href="bugs.html">Bugs, Bugzilla, and the TIFF mailing list</a></li> - <li><a href="images.html">Test images</a></li> - <li><a href="misc.html">Acknowledgements and copyright issues</a></li> - <li><a href="man/index.html">Man Pages</a></li> - </ul> - <hr> - <p> - Last updated $Date: 2009-08-28 16:24:13 $. - </p> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/internals.html b/src/3rdparty/libtiff/html/internals.html deleted file mode 100644 index 3cc9673..0000000 --- a/src/3rdparty/libtiff/html/internals.html +++ /dev/null @@ -1,572 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Modifying The TIFF Library -</TITLE> -</HEAD> -<BODY BGCOLOR=white> -<FONT FACE="Arial, Helvetica, Sans"> -<H1> -<IMG SRC=images/dave.gif WIDTH=107 HEIGHT=148 BORDER=2 ALIGN=left HSPACE=6> -Modifying The TIFF Library -</H1> - - -<P> -This chapter provides information about the internal structure of -the library, how to control the configuration when building it, and -how to add new support to the library. -The following sections are found in this chapter: - -<UL> -<LI><A HREF=#Config>Library Configuration</A> -<LI><A HREF=#Portability>General Portability Comments</A> -<LI><A HREF="#Types">Types and Portability</A> -<LI><A HREF="addingtags.html">Adding New Tags</A> -<LI><A HREF=#AddingCODECS>Adding New Builtin Codecs</A> -<LI><A HREF="addingtags.html#AddingCODECTags">Adding New Codec-private Tags</A> -<LI><A HREF=#Other>Other Comments</A> -</UL> - - -<A NAME="Config"><P><HR WIDTH=65% ALIGN=right><H3>Library Configuration</H3></A> - -Information on compiling the library is given -<A HREF=build.html>elsewhere in this documentation</A>. -This section describes the low-level mechanisms used to control -the optional parts of the library that are configured at build -time. Control is based on -a collection of C defines that are specified either on the compiler -command line or in a configuration file such as <TT>port.h</TT> -(as generated by the <TT>configure</TT> script for UNIX systems) -or <B>tiffconf.h</B>. - -<P> -Configuration defines are split into three areas: -<UL> -<LI>those that control which compression schemes are - configured as part of the builtin codecs, -<LI>those that control support for groups of tags that - are considered optional, and -<LI>those that control operating system or machine-specific support. -</UL> - -<P> -If the define <TT>COMPRESSION_SUPPORT</TT> is <STRONG>not defined</STRONG> -then a default set of compression schemes is automatically -configured: -<UL> -<LI>CCITT Group 3 and 4 algorithms (compression codes 2, 3, 4, and 32771), -<LI>the Macintosh PackBits algorithm (compression 32773), -<LI>a 4-bit run-length encoding scheme from ThunderScan (compression 32809), -<LI>a 2-bit encoding scheme used by NeXT (compression 32766), and -<LI>two experimental schemes intended for images with high dynamic range -(compression 34676 and 34677). -</UL> - -<P> - -To override the default compression behaviour define -<TT>COMPRESSION_SUPPORT</TT> and then one or more additional defines -to enable configuration of the appropriate codecs (see the table -below); e.g. - -<UL><PRE> -#define COMPRESSION_SUPPORT -#define CCITT_SUPPORT -#define PACKBITS_SUPPORT -</PRE></UL> - -Several other compression schemes are configured separately from -the default set because they depend on ancillary software -packages that are not distributed with <TT>libtiff</TT>. - -<P> -Support for JPEG compression is controlled by <TT>JPEG_SUPPORT</TT>. -The JPEG codec that comes with <TT>libtiff</TT> is designed for -use with release 5 or later of the Independent JPEG Group's freely -available software distribution. -This software can be retrieved from the directory -<A HREF=ftp://ftp.uu.net/graphics/jpeg>ftp.uu.net:/graphics/jpeg/</A>. - - -<P> -<IMG SRC="images/info.gif" ALT="NOTE: " ALIGN=left HSPACE=8> -<EM>Enabling JPEG support automatically enables support for -the TIFF 6.0 colorimetry and YCbCr-related tags.</EM> - -<P> -Experimental support for the deflate algorithm is controlled by -<TT>DEFLATE_SUPPORT</TT>. -The deflate codec that comes with <TT>libtiff</TT> is designed -for use with version 0.99 or later of the freely available -<TT>libz</TT> library written by Jean-loup Gailly and Mark Adler. -The data format used by this library is described -in the files -<A HREF=ftp://ftp.uu.net/pub/archiving/zip/doc/zlib-3.1.doc>zlib-3.1.doc</A>, -and -<A HREF=ftp://ftp.uu.net/pub/archiving/zip/doc/deflate-1.1.doc>deflate-1.1.doc</A>, -available in the directory -<A HREF=ftp://ftp.uu.net/pub/archiving/zip/doc>ftp.uu.net:/pub/archiving/zip/doc</A>.</EM> -The library can be retried from the directory -<A HREF=ftp://ftp.uu.net/pub/archiving/zip/zlib/>ftp.uu.net:/pub/archiving/zip/zlib/</A> -(or try <A HREF=ftp://quest.jpl.nasa.gov/beta/zlib/>quest.jpl.nasa.gov:/beta/zlib/</A>). - -<P> -<IMG SRC="images/warning.gif" ALT="NOTE: " ALIGN=left HSPACE=8 VSPACE=6> -<EM>The deflate algorithm is experimental. Do not expect -to exchange files using this compression scheme; -it is included only because the similar, and more common, -LZW algorithm is claimed to be governed by licensing restrictions.</EM> - - -<P> -By default <B>tiffconf.h</B> defines -<TT>COLORIMETRY_SUPPORT</TT>, -<TT>YCBCR_SUPPORT</TT>, -and -<TT>CMYK_SUPPORT</TT>. - -<P> -<TABLE BORDER CELLPADDING=3> - -<TR><TH ALIGN=left>Define</TH><TH ALIGN=left>Description</TH></TR> - -<TR> -<TD VALIGN=top><TT>CCITT_SUPPORT</TT></TD> -<TD>CCITT Group 3 and 4 algorithms (compression codes 2, 3, 4, - and 32771)</TD> -</TR> - -<TR> -<TD VALIGN=top><TT>PACKBITS_SUPPORT</TT></TD> -<TD>Macintosh PackBits algorithm (compression 32773)</TD> -</TR> - -<TR> -<TD VALIGN=top><TT>LZW_SUPPORT</TT></TD> -<TD>Lempel-Ziv & Welch (LZW) algorithm (compression 5)</TD> -</TR> - -<TR> -<TD VALIGN=top><TT>THUNDER_SUPPORT</TT></TD> -<TD>4-bit -run-length encoding scheme from ThunderScan (compression 32809)</TD> -</TR> - -<TR> -<TD VALIGN=top><TT>NEXT_SUPPORT</TT></TD> -<TD>2-bit encoding scheme used by NeXT (compression 32766)</TD> -</TR> - -<TR> -<TD VALIGN=top><TT>OJPEG_SUPPORT</TT></TD> -<TD>obsolete JPEG scheme defined in the 6.0 spec (compression 6)</TD> -</TR> - -<TR> -<TD VALIGN=top><TT>JPEG_SUPPORT</TT></TD> -<TD>current JPEG scheme defined in TTN2 (compression 7)</TD> -</TR> - -<TR> -<TD VALIGN=top><TT>ZIP_SUPPORT</TT></TD> -<TD>experimental Deflate scheme (compression 32946)</TD> -</TR> - -<TR> -<TD VALIGN=top><TT>PIXARLOG_SUPPORT</TT></TD> -<TD>Pixar's compression scheme for high-resolution color images (compression 32909)</TD> -</TR> - -<TR> -<TD VALIGN=top><TT>SGILOG_SUPPORT</TT></TD> -<TD>SGI's compression scheme for high-resolution color images (compression 34676 and 34677)</TD> -</TR> - -<TR> -<TD VALIGN=top><TT>COLORIMETRY_SUPPORT</TT></TD> -<TD>support for the TIFF 6.0 colorimetry tags</TD> -</TR> - -<TR> -<TD VALIGN=top><TT>YCBCR_SUPPORT</TT></TD> -<TD>support for the TIFF 6.0 YCbCr-related tags</TD> -</TR> - -<TR> -<TD VALIGN=top><TT>CMYK_SUPPORT</TT></TD> -<TD>support for the TIFF 6.0 CMYK-related tags</TD> -</TR> - -<TR> -<TD VALIGN=top><TT>ICC_SUPPORT</TT></TD> -<TD>support for the ICC Profile tag; see -<I>The ICC Profile Format Specification</I>, -Annex B.3 "Embedding ICC Profiles in TIFF Files"; -available at -<A HREF=http://www.color.org>http://www.color.org</A> -</TD> -</TR> - -</TABLE> - - -<A NAME="Portability"><P><HR WIDTH=65% ALIGN=right><H3>General Portability Comments</H3></A> - -This software is developed on Silicon Graphics UNIX -systems (big-endian, MIPS CPU, 32-bit ints, -IEEE floating point). -The <TT>configure</TT> shell script generates the appropriate -include files and make files for UNIX systems. -Makefiles exist for non-UNIX platforms that the -code runs on -- this work has mostly been done by other people. - -<P> -In general, the code is guaranteed to work only on SGI machines. -In practice it is highly portable to any 32-bit or 64-bit system and much -work has been done to insure portability to 16-bit systems. -If you encounter portability problems please return fixes so -that future distributions can be improved. - -<P> -The software is written to assume an ANSI C compilation environment. -If your compiler does not support ANSI function prototypes, <TT>const</TT>, -and <TT><stdarg.h></TT> then you will have to make modifications to the -software. In the past I have tried to support compilers without <TT>const</TT> -and systems without <TT><stdarg.h></TT>, but I am -<EM>no longer interested in these -antiquated environments</EM>. With the general availability of -the freely available GCC compiler, I -see no reason to incorporate modifications to the software for these -purposes. - -<P> -An effort has been made to isolate as many of the -operating system-dependencies -as possible in two files: <B>tiffcomp.h</B> and -<B>libtiff/tif_<os>.c</B>. The latter file contains -operating system-specific routines to do I/O and I/O-related operations. -The UNIX (<B>tif_unix.c</B>), -Macintosh (<B>tif_apple.c</B>), -and VMS (<B>tif_vms.c</B>) -code has had the most use; -the MS/DOS support (<B>tif_msdos.c</B>) assumes -some level of UNIX system call emulation (i.e. -<TT>open</TT>, -<TT>read</TT>, -<TT>write</TT>, -<TT>fstat</TT>, -<TT>malloc</TT>, -<TT>free</TT>). - -<P> -Native CPU byte order is determined on the fly by -the library and does not need to be specified. -The <TT>HOST_FILLORDER</TT> and <TT>HOST_BIGENDIAN</TT> -definitions are not currently used, but may be employed by -codecs for optimization purposes. - -<P> -The following defines control general portability: - -<P> -<TABLE BORDER CELLPADDING=3 WIDTH=100%> - -<TR> -<TD VALIGN=top><TT>BSDTYPES</TT></TD> -<TD>Define this if your system does NOT define the - usual BSD typedefs: <TT>u_char</TT>, - <TT>u_short</TT>, <TT>u_int</TT>, <TT>u_long</TT>.</TD> -</TR> - -<TR> -<TD VALIGN=top><TT>HAVE_IEEEFP</TT></TD> -<TD>Define this as 0 or 1 according to the floating point - format suported by the machine. If your machine does - not support IEEE floating point then you will need to - add support to tif_machdep.c to convert between the - native format and IEEE format.</TD> -</TR> - -<TR> -<TD VALIGN=top><TT>HAVE_MMAP</TT></TD> -<TD>Define this if there is <I>mmap-style</I> support for -mapping files into memory (used only to read data).</TD> -</TR> - -<TR> -<TD VALIGN=top><TT>HOST_FILLORDER</TT></TD> -<TD>Define the native CPU bit order: one of <TT>FILLORDER_MSB2LSB</TT> - or <TT>FILLORDER_LSB2MSB</TT></TD> -</TR> - -<TR> -<TD VALIGN=top><TT>HOST_BIGENDIAN</TT></TD> -<TD>Define the native CPU byte order: 1 if big-endian (Motorola) - or 0 if little-endian (Intel); this may be used - in codecs to optimize code</TD> -</TR> -</TABLE> - -<P> -On UNIX systems <TT>HAVE_MMAP</TT> is defined through the running of -the <TT>configure</TT> script; otherwise support for memory-mapped -files is disabled. -Note that <B>tiffcomp.h</B> defines <TT>HAVE_IEEEFP</TT> to be -1 (<TT>BSDTYPES</TT> is not defined). - - -<A NAME="Types"><P><HR WIDTH=65% ALIGN=right><H3>Types and Portability</H3></A> - -The software makes extensive use of C typedefs to promote portability. -Two sets of typedefs are used, one for communication with clients -of the library and one for internal data structures and parsing of the -TIFF format. There are interactions between these two to be careful -of, but for the most part you should be able to deal with portability -purely by fiddling with the following machine-dependent typedefs: - - -<P> -<TABLE BORDER CELLPADDING=3 WIDTH=100%> - -<TR> -<TD>uint8</TD> -<TD>8-bit unsigned integer</TD> -<TD>tiff.h</TD> -</TR> - -<TR> -<TD>int8</TD> -<TD>8-bit signed integer</TD> -<TD>tiff.h</TD> -</TR> - -<TR> -<TD>uint16</TD> -<TD>16-bit unsigned integer</TD> -<TD>tiff.h</TD> -</TR> - -<TR> -<TD>int16</TD> -<TD>16-bit signed integer</TD> -<TD>tiff.h</TD> -</TR> - -<TR> -<TD>uint32</TD> -<TD>32-bit unsigned integer</TD> -<TD>tiff.h</TD> -</TR> - -<TR> -<TD>int32</TD> -<TD>32-bit signed integer</TD> -<TD>tiff.h</TD> -</TR> - -<TR> -<TD>dblparam_t</TD> -<TD>promoted type for floats</TD> -<TD>tiffcomp.h</TD> -</TR> - -</TABLE> - -<P> -(to clarify <TT>dblparam_t</TT>, it is the type that float parameters are -promoted to when passed by value in a function call.) - -<P> -The following typedefs are used throughout the library and interfaces -to refer to certain objects whose size is dependent on the TIFF image -structure: - - -<P> -<TABLE BORDER CELLPADDING=3 WIDTH=100%> - -<TR> -<TD WIDTH=25%>typedef unsigned int ttag_t;</TD> <TD>directory tag</TD> -</TR> - -<TR> -<TD>typedef uint16 tdir_t;</TD> <TD>directory index</TD> -</TR> - -<TR> -<TD>typedef uint16 tsample_t;</TD> <TD>sample number</TD> -</TR> - -<TR> -<TD>typedef uint32 tstrip_t;</TD> <TD>strip number</TD> -</TR> - -<TR> -<TD>typedef uint32 ttile_t;</TD> <TD>tile number</TD> -</TR> - -<TR> -<TD>typedef int32 tsize_t;</TD> <TD>i/o size in bytes</TD> -</TR> - -<TR> -<TD>typedef void* tdata_t;</TD> <TD>image data ref</TD> -</TR> - -<TR> -<TD>typedef void* thandle_t;</TD> <TD>client data handle</TD> -</TR> - -<TR> -<TD>typedef int32 toff_t;</TD> <TD>file offset (should be off_t)</TD> -</TR> - -<TR> -<TD>typedef unsigned char* tidata_t;</TD> <TD>internal image data</TD> -</TR> - -</TABLE> - -<P> -Note that <TT>tstrip_t</TT>, <TT>ttile_t</TT>, and <TT>tsize_t</TT> -are constrained to be -no more than 32-bit quantities by 32-bit fields they are stored -in in the TIFF image. Likewise <TT>tsample_t</TT> is limited by the 16-bit -field used to store the <TT>SamplesPerPixel</TT> tag. <TT>tdir_t</TT> -constrains -the maximum number of IFDs that may appear in an image and may -be an arbitrary size (without penalty). <TT>ttag_t</TT> must be either -<TT>int</TT>, <TT>unsigned int</TT>, pointer, or <TT>double</TT> -because the library uses a varargs -interface and ANSI C restricts the type of the parameter before an -ellipsis to be a promoted type. <TT>toff_t</TT> is defined as -<TT>int32</TT> because -TIFF file offsets are (unsigned) 32-bit quantities. A signed -value is used because some interfaces return -1 on error (sigh). -Finally, note that <TT>tidata_t</TT> is used internally to the library to -manipulate internal data. User-specified data references are -passed as opaque handles and only cast at the lowest layers where -their type is presumed. - - -<P><HR WIDTH=65% ALIGN=right><H3>General Comments</H3></A> - -The library is designed to hide as much of the details of TIFF from -applications as -possible. In particular, TIFF directories are read in their entirety -into an internal format. Only the tags known by the library are -available to a user and certain tag data may be maintained that a user -does not care about (e.g. transfer function tables). - -<A NAME=AddingCODECS><P><HR WIDTH=65% ALIGN=right><H3>Adding New Builtin Codecs</H3></A> - -To add builtin support for a new compression algorithm, you can either -use the "tag-extension" trick to override the handling of the -TIFF Compression tag (see <A HREF=addingtags.html>Adding New Tags</A>), -or do the following to add support directly to the core library: - -<OL> -<LI>Define the tag value in <B>tiff.h</B>. -<LI>Edit the file <B>tif_codec.c</B> to add an entry to the - _TIFFBuiltinCODECS array (see how other algorithms are handled). -<LI>Add the appropriate function prototype declaration to - <B>tiffiop.h</B> (close to the bottom). -<LI>Create a file with the compression scheme code, by convention files - are named <B>tif_*.c</B> (except perhaps on some systems where the - tif_ prefix pushes some filenames over 14 chars. -<LI>Edit <B>Makefile.in</B> (and any other Makefiles) - to include the new source file. -</OL> - -<P> -A codec, say <TT>foo</TT>, can have many different entry points: - -<PRE> -TIFFInitfoo(tif, scheme)/* initialize scheme and setup entry points in tif */ -fooSetupDecode(tif) /* called once per IFD after tags has been frozen */ -fooPreDecode(tif, sample)/* called once per strip/tile, after data is read, - but before the first row is decoded */ -fooDecode*(tif, bp, cc, sample)/* decode cc bytes of data into the buffer */ - fooDecodeRow(...) /* called to decode a single scanline */ - fooDecodeStrip(...) /* called to decode an entire strip */ - fooDecodeTile(...) /* called to decode an entire tile */ -fooSetupEncode(tif) /* called once per IFD after tags has been frozen */ -fooPreEncode(tif, sample)/* called once per strip/tile, before the first row in - a strip/tile is encoded */ -fooEncode*(tif, bp, cc, sample)/* encode cc bytes of user data (bp) */ - fooEncodeRow(...) /* called to decode a single scanline */ - fooEncodeStrip(...) /* called to decode an entire strip */ - fooEncodeTile(...) /* called to decode an entire tile */ -fooPostEncode(tif) /* called once per strip/tile, just before data is written */ -fooSeek(tif, row) /* seek forwards row scanlines from the beginning - of a strip (row will always be >0 and <rows/strip */ -fooCleanup(tif) /* called when compression scheme is replaced by user */ -</PRE> - -<P> -Note that the encoding and decoding variants are only needed when -a compression algorithm is dependent on the structure of the data. -For example, Group 3 2D encoding and decoding maintains a reference -scanline. The sample parameter identifies which sample is to be -encoded or decoded if the image is organized with <TT>PlanarConfig</TT>=2 -(separate planes). This is important for algorithms such as JPEG. -If <TT>PlanarConfig</TT>=1 (interleaved), then sample will always be 0. - -<A NAME=Other><P><HR WIDTH=65% ALIGN=right><H3>Other Comments</H3></A> - -The library handles most I/O buffering. There are two data buffers -when decoding data: a raw data buffer that holds all the data in a -strip, and a user-supplied scanline buffer that compression schemes -place decoded data into. When encoding data the data in the -user-supplied scanline buffer is encoded into the raw data buffer (from -where it is written). Decoding routines should never have to explicitly -read data -- a full strip/tile's worth of raw data is read and scanlines -never cross strip boundaries. Encoding routines must be cognizant of -the raw data buffer size and call <TT>TIFFFlushData1()</TT> when necessary. -Note that any pending data is automatically flushed when a new strip/tile is -started, so there's no need do that in the tif_postencode routine (if -one exists). Bit order is automatically handled by the library when -a raw strip or tile is filled. If the decoded samples are interpreted -by the decoding routine before they are passed back to the user, then -the decoding logic must handle byte-swapping by overriding the -<TT>tif_postdecode</TT> -routine (set it to <TT>TIFFNoPostDecode</TT>) and doing the required work -internally. For an example of doing this look at the horizontal -differencing code in the routines in <B>tif_predict.c</B>. - -<P> -The variables <TT>tif_rawcc</TT>, <TT>tif_rawdata</TT>, and -<TT>tif_rawcp</TT> in a <TT>TIFF</TT> structure -are associated with the raw data buffer. <TT>tif_rawcc</TT> must be non-zero -for the library to automatically flush data. The variable -<TT>tif_scanlinesize</TT> is the size a user's scanline buffer should be. The -variable <TT>tif_tilesize</TT> is the size of a tile for tiled images. This -should not normally be used by compression routines, except where it -relates to the compression algorithm. That is, the <TT>cc</TT> parameter to the -<TT>tif_decode*</TT> and <TT>tif_encode*</TT> -routines should be used in terminating -decompression/compression. This ensures these routines can be used, -for example, to decode/encode entire strips of data. - -<P> -In general, if you have a new compression algorithm to add, work from -the code for an existing routine. In particular, -<B>tif_dumpmode.c</B> -has the trivial code for the "nil" compression scheme, -<B>tif_packbits.c</B> is a -simple byte-oriented scheme that has to watch out for buffer -boundaries, and <B>tif_lzw.c</B> has the LZW scheme that has the most -complexity -- it tracks the buffer boundary at a bit level. -Of course, using a private compression scheme (or private tags) limits -the portability of your TIFF files. - -<P> -<HR> - -Last updated: $Date: 2004/09/10 14:47:31 $ - -</BODY> - -</HTML> diff --git a/src/3rdparty/libtiff/html/intro.html b/src/3rdparty/libtiff/html/intro.html deleted file mode 100644 index 61c01d4..0000000 --- a/src/3rdparty/libtiff/html/intro.html +++ /dev/null @@ -1,68 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Introduction to the TIFF Documentation -</TITLE> -</HEAD> -<BODY BGCOLOR=white> -<FONT FACE="Arial, Helvetica, Sans"> -<H1> -<IMG SRC=images/strike.gif WIDTH=128 HEIGHT=100 ALIGN=left HSPACE=6> -Introduction to the TIFF Documentation -</H1> - - -<P> -The following definitions are used throughout this documentation. -They are consistent with the terminology used in the TIFF 6.0 specification. - -<DL> -<DT><I>Sample</I> -<DD>The unit of information stored in an image; often called a - channel elsewhere. Sample values are numbers, usually unsigned - integers, but possibly in some other format if the SampleFormat - tag is specified in a TIFF -<DT><I>Pixel</I> -<DD>A collection of one or more samples that go together. -<DT><I>Row</I> -<DD>An Nx1 rectangular collection of pixels. -<DT><I>Tile</I> -<DD>An NxM rectangular organization of data (or pixels). -<DT><I>Strip</I> -<DD>A tile whose width is the full image width. -<DT><I>Compression</I> -<DD>A scheme by which pixel or sample data are stored in - an encoded form, specifically with the intent of reducing the - storage cost. -<DT><I>Codec</I> -<DD>Software that implements the decoding and encoding algorithms - of a compression scheme. -</UL> - -<P> -In order to better understand how TIFF works (and consequently this -software) it is important to recognize the distinction between the -physical organization of image data as it is stored in a TIFF and how -the data is interpreted and manipulated as pixels in an image. TIFF -supports a wide variety of storage and data compression schemes that -can be used to optimize retrieval time and/or minimize storage space. -These on-disk formats are independent of the image characteristics; it -is the responsibility of the TIFF reader to process the on-disk storage -into an in-memory format suitable for an application. Furthermore, it -is the responsibility of the application to properly interpret the -visual characteristics of the image data. TIFF defines a framework for -specifying the on-disk storage format and image characteristics with -few restrictions. This permits significant complexity that can be -daunting. Good applications that handle TIFF work by handling as wide -a range of storage formats as possible, while constraining the -acceptable image characteristics to those that make sense for the -application. - - -<P> -<HR> - -Last updated: $Date: 1999/08/09 20:21:21 $ - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/libtiff.html b/src/3rdparty/libtiff/html/libtiff.html deleted file mode 100644 index 6a2c42e..0000000 --- a/src/3rdparty/libtiff/html/libtiff.html +++ /dev/null @@ -1,747 +0,0 @@ -<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html lang="en"> -<head> - <title>Using The TIFF Library</title> - <meta http-equiv="content-type" content="text/html; charset=ISO-8859-1"> - <meta http-equiv="content-language" content="en"> - <style type="text/css"> - <!-- - th {text-align: left; vertical-align: top; font-style: italic; font-weight: normal} - --> - </style> -</head> -<body lang="en" text="#000000" bgcolor="#ffffff" link="#0000ff" alink="#0000ff" vlink="#0000ff"> - <table border="0" cellspacing="0" cellpadding="0"> - <tr> - <td style="padding-left: 1em; padding-right: 1em"><img src="images/cat.gif" width="113" height="146" alt=""></td> - <td> - <h1>Using The TIFF Library</h1> - <p> - <tt>libtiff</tt> is a set of C functions (a library) that support - the manipulation of TIFF image files. - The library requires an ANSI C compilation environment for building - and presumes an ANSI C environment for use. - </p> - </td> - </tr> - </table> - <br> - <p> - <tt>libtiff</tt> - provides interfaces to image data at several layers of abstraction (and cost). - At the highest level image data can be read into an 8-bit/sample, - ABGR pixel raster format without regard for the underlying data organization, - colorspace, or compression scheme. Below this high-level interface - the library provides scanline-, strip-, and tile-oriented interfaces that - return data decompressed but otherwise untransformed. These interfaces - require that the application first identify the organization of stored - data and select either a strip-based or tile-based API for manipulating - data. At the lowest level the library - provides access to the raw uncompressed strips or tiles, - returning the data exactly as it appears in the file. - </p> - <p> - The material presented in this chapter is a basic introduction - to the capabilities of the library; it is not an attempt to describe - everything a developer needs to know about the library or about TIFF. - Detailed information on the interfaces to the library are given in - the <a href="http://www.remotesensing.org/libtiff/man/index.html">UNIX - manual pages</a> that accompany this software. - </p> - <p> - Michael Still has also written a useful introduction to libtiff for the - IBM DeveloperWorks site available at - <a href="http://www.ibm.com/developerworks/linux/library/l-libtiff">http://www.ibm.com/developerworks/linux/library/l-libtiff</a>. - </p> - <p> - The following sections are found in this chapter: - </p> - <ul> - <li><a href="#version">How to tell which version you have</a></li> - <li><a href="#typedefs">Library Datatypes</a></li> - <li><a href="#mman">Memory Management</a></li> - <li><a href="#errors">Error Handling</a></li> - <li><a href="#fio">Basic File Handling</a></li> - <li><a href="#dirs">TIFF Directories</a></li> - <li><a href="#tags">TIFF Tags</a></li> - <li><a href="#compression">TIFF Compression Schemes</a></li> - <li><a href="#byteorder">Byte Order</a></li> - <li><a href="#dataplacement">Data Placement</a></li> - <li><a href="#tiffrgbaimage">TIFFRGBAImage Support</a></li> - <li><a href="#scanlines">Scanline-based Image I/O</a></li> - <li><a href="#strips">Strip-oriented Image I/O</a></li> - <li><a href="#tiles">Tile-oriented Image I/O</a></li> - <li><a href="#other">Other Stuff</a></li> - </ul> - <hr> - <h2 id="version">How to tell which version you have</h2> - <p> - The software version can be found by looking at the file named - <tt>VERSION</tt> - that is located at the top of the source tree; the precise alpha number - is given in the file <tt>dist/tiff.alpha</tt>. - If you have need to refer to this - specific software, you should identify it as: - </p> - <p style="margin-left: 40px"> - <tt>TIFF <<i>version</i>> <<i>alpha</i>></tt> - </p> - <p> - where <tt><<i>version</i>></tt> is whatever you get from - <tt>"cat VERSION"</tt> and <tt><<i>alpha</i>></tt> is - what you get from <tt>"cat dist/tiff.alpha"</tt>. - </p> - <p> - Within an application that uses <tt>libtiff</tt> the <tt>TIFFGetVersion</tt> - routine will return a pointer to a string that contains software version - information. - The library include file <tt><tiffio.h></tt> contains a C pre-processor - define <tt>TIFFLIB_VERSION</tt> that can be used to check library - version compatiblity at compile time. - </p> - <hr> - <h2 id="typedefs">Library Datatypes</h2> - <p> - <tt>libtiff</tt> defines a portable programming interface through the - use of a set of C type definitions. - These definitions, defined in in the files <b>tiff.h</b> and - <b>tiffio.h</b>, - isolate the <tt>libtiff</tt> API from the characteristics - of the underlying machine. - To insure portable code and correct operation, applications that use - <tt>libtiff</tt> should use the typedefs and follow the function - prototypes for the library API. - </p> - <hr> - <h2 id="mman">Memory Management</h2> - <p> - <tt>libtiff</tt> uses a machine-specific set of routines for managing - dynamically allocated memory. - <tt>_TIFFmalloc</tt>, <tt>_TIFFrealloc</tt>, and <tt>_TIFFfree</tt> - mimic the normal ANSI C routines. - Any dynamically allocated memory that is to be passed into the library - should be allocated using these interfaces in order to insure pointer - compatibility on machines with a segmented architecture. - (On 32-bit UNIX systems these routines just call the normal <tt>malloc</tt>, - <tt>realloc</tt>, and <tt>free</tt> routines in the C library.) - </p> - <p> - To deal with segmented pointer issues <tt>libtiff</tt> also provides - <tt>_TIFFmemcpy</tt>, <tt>_TIFFmemset</tt>, and <tt>_TIFFmemmove</tt> - routines that mimic the equivalent ANSI C routines, but that are - intended for use with memory allocated through <tt>_TIFFmalloc</tt> - and <tt>_TIFFrealloc</tt>. - </p> - <hr> - <h2 id="errors">Error Handling</h2> - <p> - <tt>libtiff</tt> handles most errors by returning an invalid/erroneous - value when returning from a function call. - Various diagnostic messages may also be generated by the library. - All error messages are directed to a single global error handler - routine that can be specified with a call to <tt>TIFFSetErrorHandler</tt>. - Likewise warning messages are directed to a single handler routine - that can be specified with a call to <tt>TIFFSetWarningHandler</tt> - </p> - <hr> - <h2 id="fio">Basic File Handling</h2> - <p> - The library is modeled after the normal UNIX stdio library. - For example, to read from an existing TIFF image the - file must first be opened: - </p> - <p style="margin-left: 40px"> - <tt>#include "tiffio.h"<br> - main()<br> - {<br> - TIFF* tif = TIFFOpen("foo.tif", "r");<br> - ... do stuff ...<br> - TIFFClose(tif);<br> - }</tt> - </p> - <p> - The handle returned by <tt>TIFFOpen</tt> is <i>opaque</i>, that is - the application is not permitted to know about its contents. - All subsequent library calls for this file must pass the handle - as an argument. - </p> - <p> - To create or overwrite a TIFF image the file is also opened, but with - a <tt>"w"</tt> argument: - <p> - <p style="margin-left: 40px"> - <tt>#include "tiffio.h"<br> - main()<br> - {<br> - TIFF* tif = TIFFOpen("foo.tif", "w");<br> - ... do stuff ...<br> - TIFFClose(tif);<br> - }</tt> - </p> - <p> - If the file already exists it is first truncated to zero length. - </p> - <table> - <tr> - <td valign=top><img src="images/warning.gif" width="40" height="40" alt=""></td> - <td><i>Note that unlike the stdio library TIFF image files may not be - opened for both reading and writing; - there is no support for altering the contents of a TIFF file.</i></td> - </tr> - </table> - <p> - <tt>libtiff</tt> buffers much information associated with writing a - valid TIFF image. Consequently, when writing a TIFF image it is necessary - to always call <tt>TIFFClose</tt> or <tt>TIFFFlush</tt> to flush any - buffered information to a file. Note that if you call <tt>TIFFClose</tt> - you do not need to call <tt>TIFFFlush</tt>. - </p> - <hr> - <h2 id="dirs">TIFF Directories</h2> - <p> - TIFF supports the storage of multiple images in a single file. - Each image has an associated data structure termed a <i>directory</i> - that houses all the information about the format and content of the - image data. - Images in a file are usually related but they do not need to be; it - is perfectly alright to store a color image together with a black and - white image. - Note however that while images may be related their directories are - not. - That is, each directory stands on its own; their is no need to read - an unrelated directory in order to properly interpret the contents - of an image. - </p> - <p> - <tt>libtiff</tt> provides several routines for reading and writing - directories. In normal use there is no need to explicitly - read or write a directory: the library automatically reads the first - directory in a file when opened for reading, and directory information - to be written is automatically accumulated and written when writing - (assuming <tt>TIFFClose</tt> or <tt>TIFFFlush</tt> are called). - </p> - <p> - For a file open for reading the <tt>TIFFSetDirectory</tt> routine can - be used to select an arbitrary directory; directories are referenced by - number with the numbering starting at 0. Otherwise the - <tt>TIFFReadDirectory</tt> and <tt>TIFFWriteDirectory</tt> routines can - be used for sequential access to directories. - For example, to count the number of directories in a file the following - code might be used: - </p> - <p style="margin-left: 40px"> - <tt>#include "tiffio.h"<br> - main(int argc, char* argv[])<br> - {<br> - TIFF* tif = TIFFOpen(argv[1], "r");<br> - if (tif) {<br> - int dircount = 0;<br> - do {<br> - dircount++;<br> - } while (TIFFReadDirectory(tif));<br> - printf("%d directories in %s\n", dircount, argv[1]);<br> - TIFFClose(tif);<br> - }<br> - exit(0);<br> - }</tt> - </p> - <p> - Finally, note that there are several routines for querying the - directory status of an open file: - <tt>TIFFCurrentDirectory</tt> returns the index of the current - directory and - <tt>TIFFLastDirectory</tt> returns an indication of whether the - current directory is the last directory in a file. - There is also a routine, <tt>TIFFPrintDirectory</tt>, that can - be called to print a formatted description of the contents of - the current directory; consult the manual page for complete details. - </p> - <hr> - <h2 id="tags">TIFF Tags</h2> - <p> - Image-related information such as the image width and height, number - of samples, orientation, colorimetric information, etc. - are stored in each image - directory in <i>fields</i> or <i>tags</i>. - Tags are identified by a number that is usually a value registered - with the Aldus (now Adobe) Corporation. - Beware however that some vendors write - TIFF images with tags that are unregistered; in this case interpreting - their contents is usually a waste of time. - </p> - <p> - <tt>libtiff</tt> reads the contents of a directory all at once - and converts the on-disk information to an appropriate in-memory - form. While the TIFF specification permits an arbitrary set of - tags to be defined and used in a file, the library only understands - a limited set of tags. - Any unknown tags that are encountered in a file are ignored. - There is a mechanism to extend the set of tags the library handles - without modifying the library itself; - this is described <a href="addingtags.html">elsewhere</a>. - </p> - <p> - <tt>libtiff</tt> provides two interfaces for getting and setting tag - values: <tt>TIFFGetField</tt> and <tt>TIFFSetField</tt>. - These routines use a variable argument list-style interface to pass - parameters of different type through a single function interface. - The <i>get interface</i> takes one or more pointers to memory locations - where the tag values are to be returned and also returns one or - zero according to whether the requested tag is defined in the directory. - The <i>set interface</i> takes the tag values either by-reference or - by-value. - The TIFF specification defines - <i>default values</i> for some tags. - To get the value of a tag, or its default value if it is undefined, - the <tt>TIFFGetFieldDefaulted</tt> interface may be used. - </p> - <p> - The manual pages for the tag get and set routines specifiy the exact data types - and calling conventions required for each tag supported by the library. - </p> - <hr> - <h2 id="compression">TIFF Compression Schemes</h2> - <p> - <tt>libtiff</tt> includes support for a wide variety of - data compression schemes. - In normal operation a compression scheme is automatically used when - the TIFF <tt>Compression</tt> tag is set, either by opening a file - for reading, or by setting the tag when writing. - </p> - <p> - Compression schemes are implemented by software modules termed <i>codecs</i> - that implement decoder and encoder routines that hook into the - core library i/o support. - Codecs other than those bundled with the library can be registered - for use with the <tt>TIFFRegisterCODEC</tt> routine. - This interface can also be used to override the core-library - implementation for a compression scheme. - </p> - <hr> - <h2 id="byteorder">Byte Order</h2> - <p> - The TIFF specification says, and has always said, that - <em>a correct TIFF - reader must handle images in big-endian and little-endian byte order</em>. - <tt>libtiff</tt> conforms in this respect. - Consequently there is no means to force a specific - byte order for the data written to a TIFF image file (data is - written in the native order of the host CPU unless appending to - an existing file, in which case it is written in the byte order - specified in the file). - </p> - <hr> - <h2 id="dataplacement">Data Placement</h2> - <p> - The TIFF specification requires that all information except an - 8-byte header can be placed anywhere in a file. - In particular, it is perfectly legitimate for directory information - to be written after the image data itself. - Consequently TIFF is inherently not suitable for passing through a - stream-oriented mechanism such as UNIX pipes. - Software that require that data be organized in a file in a particular - order (e.g. directory information before image data) does not - correctly support TIFF. - <tt>libtiff</tt> provides no mechanism for controlling the placement - of data in a file; image data is typically written before directory - information. - </p> - <hr> - <h2 id="tiffrgbaimage">TIFFRGBAImage Support</h2> - <p> - <tt>libtiff</tt> provides a high-level interface for reading image - data from a TIFF file. This interface handles the details of - data organization and format for a wide variety of TIFF files; - at least the large majority of those files that one would normally - encounter. Image data is, by default, returned as ABGR - pixels packed into 32-bit words (8 bits per sample). Rectangular - rasters can be read or data can be intercepted at an intermediate - level and packed into memory in a format more suitable to the - application. - The library handles all the details of the format of data stored on - disk and, in most cases, if any colorspace conversions are required: - bilevel to RGB, greyscale to RGB, CMYK to RGB, YCbCr to RGB, 16-bit - samples to 8-bit samples, associated/unassociated alpha, etc. - </p> - <p> - There are two ways to read image data using this interface. If - all the data is to be stored in memory and manipulated at once, - then the routine <tt>TIFFReadRGBAImage</tt> can be used: - </p> - <p> - <p style="margin-left: 40px"> - <tt>#include "tiffio.h"<br> - main(int argc, char* argv[])<br> - {<br> - TIFF* tif = TIFFOpen(argv[1], "r");<br> - if (tif) {<br> - uint32 w, h;<br> - size_t npixels;<br> - uint32* raster;<br> - <br> - TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &w);<br> - TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &h);<br> - npixels = w * h;<br> - raster = (uint32*) _TIFFmalloc(npixels * sizeof (uint32));<br> - if (raster != NULL) {<br> - if (TIFFReadRGBAImage(tif, w, h, raster, 0)) {<br> - ...process raster data...<br> - }<br> - _TIFFfree(raster);<br> - }<br> - TIFFClose(tif);<br> - }<br> - exit(0);<br> - }</tt> - </p> - <p> - Note above that <tt>_TIFFmalloc</tt> is used to allocate memory for - the raster passed to <tt>TIFFReadRGBAImage</tt>; this is important - to insure the ``appropriate type of memory'' is passed on machines - with segmented architectures. - </p> - <p> - Alternatively, <tt>TIFFReadRGBAImage</tt> can be replaced with a - more low-level interface that permits an application to have more - control over this reading procedure. The equivalent to the above - is: - </p> - <p style="margin-left: 40px"> - <tt>#include "tiffio.h"<br> - main(int argc, char* argv[])<br> - {<br> - TIFF* tif = TIFFOpen(argv[1], "r");<br> - if (tif) {<br> - TIFFRGBAImage img;<br> - char emsg[1024];<br> - <br> - if (TIFFRGBAImageBegin(&img, tif, 0, emsg)) {<br> - size_t npixels;<br> - uint32* raster;<br> - <br> - npixels = img.width * img.height;<br> - raster = (uint32*) _TIFFmalloc(npixels * sizeof (uint32));<br> - if (raster != NULL) {<br> - if (TIFFRGBAImageGet(&img, raster, img.width, img.height)) {<br> - ...process raster data...<br> - }<br> - _TIFFfree(raster);<br> - }<br> - TIFFRGBAImageEnd(&img);<br> - } else<br> - TIFFError(argv[1], emsg);<br> - TIFFClose(tif);<br> - }<br> - exit(0);<br> - }</tt> - </p> - <p> - However this usage does not take advantage of the more fine-grained - control that's possible. That is, by using this interface it is - possible to: - </p> - <ul> - <li>repeatedly fetch (and manipulate) an image without opening - and closing the file</li> - <li>interpose a method for packing raster pixel data according to - application-specific needs (or write the data at all)</li> - <li>interpose methods that handle TIFF formats that are not already - handled by the core library</li> - </ul> - <p> - The first item means that, for example, image viewers that want to - handle multiple files can cache decoding information in order to - speedup the work required to display a TIFF image. - </p> - <p> - The second item is the main reason for this interface. By interposing - a "put method" (the routine that is called to pack pixel data in - the raster) it is possible share the core logic that understands how - to deal with TIFF while packing the resultant pixels in a format that - is optimized for the application. This alternate format might be very - different than the 8-bit per sample ABGR format the library writes by - default. For example, if the application is going to display the image - on an 8-bit colormap display the put routine might take the data and - convert it on-the-fly to the best colormap indices for display. - </p> - <p> - The last item permits an application to extend the library - without modifying the core code. - By overriding the code provided an application might add support - for some esoteric flavor of TIFF that it needs, or it might - substitute a packing routine that is able to do optimizations - using application/environment-specific information. - </p> - <p> - The TIFF image viewer found in <b>tools/sgigt.c</b> is an example - of an application that makes use of the <tt>TIFFRGBAImage</tt> - support. - </p> - <hr> - <h2 id="scanlines">Scanline-based Image I/O</h2> - <p> - The simplest interface provided by <tt>libtiff</tt> is a - scanline-oriented interface that can be used to read TIFF - images that have their image data organized in strips - (trying to use this interface to read data written in tiles - will produce errors.) - A scanline is a one pixel high row of image data whose width - is the width of the image. - Data is returned packed if the image data is stored with samples - packed together, or as arrays of separate samples if the data - is stored with samples separated. - The major limitation of the scanline-oriented interface, other - than the need to first identify an existing file as having a - suitable organization, is that random access to individual - scanlines can only be provided when data is not stored in a - compressed format, or when the number of rows in a strip - of image data is set to one (<tt>RowsPerStrip</tt> is one). - </p> - <p> - Two routines are provided for scanline-based i/o: - <tt>TIFFReadScanline</tt> - and - <tt>TIFFWriteScanline</tt>. - For example, to read the contents of a file that - is assumed to be organized in strips, the following might be used: - </p> - <p style="margin-left: 40px"> - <tt>#include "tiffio.h"<br> - main()<br> - {<br> - TIFF* tif = TIFFOpen("myfile.tif", "r");<br> - if (tif) {<br> - uint32 imagelength;<br> - tdata_t buf;<br> - uint32 row;<br> - <br> - TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &imagelength);<br> - buf = _TIFFmalloc(TIFFScanlineSize(tif));<br> - for (row = 0; row < imagelength; row++)<br> - tiffreadscanline(tif, buf, row);<br> - _tifffree(buf);<br> - tiffclose(tif);<br> - }<br> - }</tt> - </p> - <p> - <tt>TIFFScanlineSize</tt> returns the number of bytes in - a decoded scanline, as returned by <tt>TIFFReadScanline</tt>. - Note however that if the file had been create with samples - written in separate planes, then the above code would only - read data that contained the first sample of each pixel; - to handle either case one might use the following instead: - </p> - <p style="margin-left: 40px"> - <tt>#include "tiffio.h"<br> - main()<br> - {<br> - TIFF* tif = TIFFOpen("myfile.tif", "r");<br> - if (tif) {<br> - uint32 imagelength;<br> - tdata_t buf;<br> - uint32 row;<br> - <br> - TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &imagelength);<br> - TIFFGetField(tif, TIFFTAG_PLANARCONFIG, &config);<br> - buf = _TIFFmalloc(TIFFScanlineSize(tif));<br> - if (config == PLANARCONFIG_CONTIG) {<br> - for (row = 0; row < imagelength; row++)<br> - tiffreadscanline(tif, buf, row);<br> - } else if (config == planarconfig_separate) {<br> - uint16 s, nsamples;<br> - <br> - tiffgetfield(tif, tifftag_samplesperpixel, &nsamples);<br> - for (s = 0; s < nsamples; s++)<br> - for (row = 0; row < imagelength; row++)<br> - tiffreadscanline(tif, buf, row, s);<br> - }<br> - _tifffree(buf);<br> - tiffclose(tif);<br> - }<br> - }</tt> - </p> - <p> - Beware however that if the following code were used instead to - read data in the case <tt>PLANARCONFIG_SEPARATE</tt>,... - </p> - <p style="margin-left: 40px"> - <tt> for (row = 0; row < imagelength; row++)<br> - for (s = 0; s < nsamples; s++)<br> - tiffreadscanline(tif, buf, row, s);</tt> - </p> - <p> - ...then problems would arise if <tt>RowsPerStrip</tt> was not one - because the order in which scanlines are requested would require - random access to data within strips (something that is not supported - by the library when strips are compressed). - </p> - <hr> - <h2 id="strips">Strip-oriented Image I/O</h2> - <p> - The strip-oriented interfaces provided by the library provide - access to entire strips of data. Unlike the scanline-oriented - calls, data can be read or written compressed or uncompressed. - Accessing data at a strip (or tile) level is often desirable - because there are no complications with regard to random access - to data within strips. - </p> - <p> - A simple example of reading an image by strips is: - </p> - <p style="margin-left: 40px"> - <tt>#include "tiffio.h"<br> - main()<br> - {<br> - TIFF* tif = TIFFOpen("myfile.tif", "r");<br> - if (tif) {<br> - tdata_t buf;<br> - tstrip_t strip;<br> - <br> - buf = _TIFFmalloc(TIFFStripSize(tif));<br> - for (strip = 0; strip < tiffnumberofstrips(tif); strip++)<br> - tiffreadencodedstrip(tif, strip, buf, (tsize_t) -1);<br> - _tifffree(buf);<br> - tiffclose(tif);<br> - }<br> - }</tt> - </p> - <p> - Notice how a strip size of <tt>-1</tt> is used; <tt>TIFFReadEncodedStrip</tt> - will calculate the appropriate size in this case. - </p> - <p> - The above code reads strips in the order in which the - data is physically stored in the file. If multiple samples - are present and data is stored with <tt>PLANARCONFIG_SEPARATE</tt> - then all the strips of data holding the first sample will be - read, followed by strips for the second sample, etc. - </p> - <p> - Finally, note that the last strip of data in an image may have fewer - rows in it than specified by the <tt>RowsPerStrip</tt> tag. A - reader should not assume that each decoded strip contains a full - set of rows in it. - </p> - <p> - The following is an example of how to read raw strips of data from - a file: - </p> - <p style="margin-left: 40px"> - <tt>#include "tiffio.h"<br> - main()<br> - {<br> - TIFF* tif = TIFFOpen("myfile.tif", "r");<br> - if (tif) {<br> - tdata_t buf;<br> - tstrip_t strip;<br> - uint32* bc;<br> - uint32 stripsize;<br> - <br> - TIFFGetField(tif, TIFFTAG_STRIPBYTECOUNTS, &bc);<br> - stripsize = bc[0];<br> - buf = _TIFFmalloc(stripsize);<br> - for (strip = 0; strip < tiffnumberofstrips(tif); strip++) {<br> - if (bc[strip] > stripsize) {<br> - buf = _TIFFrealloc(buf, bc[strip]);<br> - stripsize = bc[strip];<br> - }<br> - TIFFReadRawStrip(tif, strip, buf, bc[strip]);<br> - }<br> - _TIFFfree(buf);<br> - TIFFClose(tif);<br> - }<br> - }</tt> - </p> - <p> - As above the strips are read in the order in which they are - physically stored in the file; this may be different from the - logical ordering expected by an application. - </p> - <hr> - <h2 id="tiles">Tile-oriented Image I/O</h2> - <p> - Tiles of data may be read and written in a manner similar to strips. - With this interface, an image is - broken up into a set of rectangular areas that may have dimensions - less than the image width and height. All the tiles - in an image have the same size, and the tile width and length must each - be a multiple of 16 pixels. Tiles are ordered left-to-right and - top-to-bottom in an image. As for scanlines, samples can be packed - contiguously or separately. When separated, all the tiles for a sample - are colocated in the file. That is, all the tiles for sample 0 appear - before the tiles for sample 1, etc. - </p> - <p> - Tiles and strips may also be extended in a z dimension to form - volumes. Data volumes are organized as "slices". That is, all the - data for a slice is colocated. Volumes whose data is organized in - tiles can also have a tile depth so that data can be organized in - cubes. - </p> - <p> - There are actually two interfaces for tiles. - One interface is similar to scanlines, to read a tiled image, - code of the following sort might be used: - </p> - <p style="margin-left: 40px"> - <tt>main()<br> - {<br> - TIFF* tif = TIFFOpen("myfile.tif", "r");<br> - if (tif) {<br> - uint32 imageWidth, imageLength;<br> - uint32 tileWidth, tileLength;<br> - uint32 x, y;<br> - tdata_t buf;<br> - <br> - TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &imageWidth);<br> - TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &imageLength);<br> - TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tileWidth);<br> - TIFFGetField(tif, TIFFTAG_TILELENGTH, &tileLength);<br> - buf = _TIFFmalloc(TIFFTileSize(tif));<br> - for (y = 0; y < imagelength; y += tilelength)<br> - for (x = 0; x < imagewidth; x += tilewidth)<br> - tiffreadtile(tif, buf, x, y, 0);<br> - _tifffree(buf);<br> - tiffclose(tif);<br> - }<br> - }</tt> - </p> - <p> - (once again, we assume samples are packed contiguously.) - </p> - <p> - Alternatively a direct interface to the low-level data is provided - a la strips. Tiles can be read with - <tt>TIFFReadEncodedTile</tt> or <tt>TIFFReadRawTile</tt>, - and written with <tt>TIFFWriteEncodedTile</tt> or - <tt>TIFFWriteRawTile</tt>. For example, to read all the tiles in an image: - </p> - <p style="margin-left: 40px"> - <tt>#include "tiffio.h"<br> - main()<br> - {<br> - TIFF* tif = TIFFOpen("myfile.tif", "r");<br> - if (tif) {<br> - tdata_t buf;<br> - ttile_t tile;<br> - <br> - buf = _TIFFmalloc(TIFFTileSize(tif));<br> - for (tile = 0; tile < tiffnumberoftiles(tif); tile++)<br> - tiffreadencodedtile(tif, tile, buf, (tsize_t) -1);<br> - _tifffree(buf);<br> - tiffclose(tif);<br> - }<br> - }</tt> - </p> - <hr> - <h2 id="other">Other Stuff</h2> - <p> - Some other stuff will almost certainly go here... - </p> - <hr> - <p> - Last updated: $Date: 2005/12/28 06:53:18 $ - </p> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFClose.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFClose.3tiff.html deleted file mode 100644 index 42e3ba8..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFClose.3tiff.html +++ /dev/null @@ -1,87 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:15 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFClose</title> -</head> -<body> - -<h1 align=center>TIFFClose</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFClose − close a previously opened -<small>TIFF</small> file</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>void TIFFClose(TIFF *</b><i>tif</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFClose</i> closes a file that was previously opened -with <b>TIFFOpen</b>(3TIFF). Any buffered data are flushed -to the file, including the contents of the current directory -(if modified); and all resources are reclaimed.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>All error messages are directed to the routine. Likewise, -warning messages are directed to the -<b>TIFFWarning</b>(3TIFF) routine.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>libtiff</b>(3TIFF), <b>TIFFOpen</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFDataWidth.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFDataWidth.3tiff.html deleted file mode 100644 index 237296e..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFDataWidth.3tiff.html +++ /dev/null @@ -1,98 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:15 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFDataWidth</title> -</head> -<body> - -<h1 align=center>TIFFDataWidth</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFDataWidth − Get the size of TIFF data types</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>int TIFFDataWidth(TIFFDataType</b> -<i>type</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFDataWidth</i> returns a size of <i>type</i> in -bytes. Currently following data types are supported:<i><br> -TIFF_BYTE<br> -TIFF_ASCII<br> -TIFF_SBYTE<br> -TIFF_UNDEFINED<br> -TIFF_SHORT<br> -TIFF_SSHORT<br> -TIFF_LONG<br> -TIFF_SLONG<br> -TIFF_FLOAT<br> -TIFF_IFD<br> -TIFF_RATIONAL<br> -TIFF_SRATIONAL<br> -TIFF_DOUBLE</i></p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFDataWidth</i> returns a number of bytes occupied -by the item of given type. 0 returned when uknown data type -supplied.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>libtiff</b>(3TIFF),</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFError.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFError.3tiff.html deleted file mode 100644 index 5d39a13..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFError.3tiff.html +++ /dev/null @@ -1,106 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:15 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFError</title> -</head> -<body> - -<h1 align=center>TIFFError</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFError, TIFFSetErrorHandler − library error -handling interface</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>void TIFFError(const char *</b><i>module</i><b>, const -char *</b><i>fmt</i><b>,</b> <i>...</i><b>)</b></p> -<!-- INDENTATION --> -<p><b>#include <stdarg.h></b></p> -<!-- INDENTATION --> -<p><b>typedef void (*TIFFErrorHandler)(const char -*</b><i>module</i><b>, const char *</b><i>fmt</i><b>, -va_list</b> <i>ap</i><b>);<br> -TIFFErrorHandler TIFFSetErrorHandler(TIFFErrorHandler -handler);</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFError</i> invokes the library-wide error handling -function to (normally) write an error message to the -<b>stderr</b>. The <i>fmt</i> parameter is a -<i>printf</i>(3S) format string, and any number arguments -can be supplied. The <i>module</i> parameter, if non-zero, -is printed before the message; it typically is used to -identify the software module in which an error is -detected.</p> -<!-- INDENTATION --> -<p>Applications that desire to capture control in the event -of an error should use <i>TIFFSetErrorHandler</i> to -override the default error handler. A <small>NULL</small> -(0) error handling function may be installed to suppress -error messages.</p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFSetErrorHandler</i> returns a reference to the -previous error handling function.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>TIFFWarning</b>(3TIFF), <b>libtiff</b>(3TIFF), -<b>printf</b>(3)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFFlush.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFFlush.3tiff.html deleted file mode 100644 index f32ccd3..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFFlush.3tiff.html +++ /dev/null @@ -1,113 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:15 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFFlush</title> -</head> -<body> - -<h1 align=center>TIFFFlush</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFFlush, TIFFFlushData − flush pending writes to -an open <small>TIFF</small> file</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>int TIFFFlush(TIFF *</b><i>tif</i><b>)<br> -int TIFFFlushData(TIFF *</b><i>tif</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFFlush</i> causes any pending writes for the -specified file (including writes for the current directory) -to be done. In normal operation this call is never needed -− the library automatically does any flushing -required.</p> -<!-- INDENTATION --> -<p><i>TIFFFlushData</i> flushes any pending image data for -the specified file to be written out; directory-related data -are not flushed. In normal operation this call is never -needed − the library automatically does any flushing -required.</p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>0 is returned if an error is encountered, otherwise 1 is -returned.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>All error messages are directed to the -<b>TIFFError</b>(3TIFF) routine.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>TIFFOpen</b>(3TIFF), -<b>TIFFWriteEncodedStrip</b>(3TIFF), -<b>TIFFWriteEncodedTile</b>(3TIFF), -<b>TIFFWriteRawStrip</b>(3TIFF), -<b>TIFFWriteRawTile</b>(3TIFF), -<b>TIFFWriteScanline</b>(3TIFF), <b>TIFFWriteTile</b>(3TIFF) -<b>libtiff</b>(3TIFF),</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFGetField.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFGetField.3tiff.html deleted file mode 100644 index e644b1d..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFGetField.3tiff.html +++ /dev/null @@ -1,1446 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:15 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFGetField</title> -</head> -<body> - -<h1 align=center>TIFFGetField</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#AUTOREGISTERED TAGS">AUTOREGISTERED TAGS</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFGetField, TIFFVGetField − get the value(s) of a -tag in an open <small>TIFF</small> file</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>int TIFFGetField(TIFF *</b><i>tif</i><b>, ttag_t</b> -<i>tag</i><b>,</b> <i>...</i><b>)</b></p> -<!-- INDENTATION --> -<p><b>#include <stdarg.h></b></p> -<!-- INDENTATION --> -<p><b>int TIFFVGetField(TIFF *</b><i>tif</i><b>, ttag_t</b> -<i>tag</i><b>, va_list</b> <i>ap</i><b>)<br> -int TIFFGetFieldDefaulted(TIFF *</b><i>tif</i><b>, -ttag_t</b> <i>tag</i><b>,</b> <i>...</i><b>)<br> -int TIFFVGetFieldDefaulted(TIFF *</b><i>tif</i><b>, -ttag_t</b> <i>tag</i><b>, va_list</b> <i>ap</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFGetField</i> returns the value of a tag or -pseudo-tag associated with the the current directory of the -opened <small>TIFF</small> file <i>tif</i>. (A -<i>pseudo-tag</i> is a parameter that is used to control the -operation of the <small>TIFF</small> library but whose value -is not read or written to the underlying file.) The file -must have been previously opened with -<i>TIFFOpen</i>(3TIFF). The tag is identified by <i>tag</i>, -one of the values defined in the include file <b>tiff.h</b> -(see also the table below). The type and number of values -returned is dependent on the tag being requested. The -programming interface uses a variable argument list as -prescribed by the <i>stdarg</i>(3) interface. The returned -values should only be interpreted if <i>TIFFGetField</i> -returns 1.</p> -<!-- INDENTATION --> -<p><i>TIFFVGetField</i> is functionally equivalent to -<i>TIFFGetField</i> except that it takes a pointer to a -variable argument list. <i>TIFFVGetField</i> is useful for -layering interfaces on top of the functionality provided by -<i>TIFFGetField</i>.</p> -<!-- INDENTATION --> -<p><i>TIFFGetFieldDefaulted</i> and -<i>TIFFVGetFieldDefaulted</i> are identical to -<i>TIFFGetField</i> and <i>TIFFVGetField</i>, except that if -a tag is not defined in the current directory and it has a -default value, then the default value is returned.</p> -<!-- INDENTATION --> -<p>The tags understood by <i>libtiff(3TIFF),</i> the number -of parameter values, and the types for the returned values -are shown below. The data types are specified as in C and -correspond to the types used to specify tag values to -<i>TIFFSetField</i>(3TIFF). Remember that -<i>TIFFGetField</i> returns parameter values, so all the -listed data types are pointers to storage where values -should be returned. Consult the <small>TIFF</small> -specification (or relevant industry specification) for -information on the meaning of each tag and their possible -values.</p></td> -</table> -<!-- TABS --> - -<p><i>Tag Name Count Types Notes</i></p> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_ARTIST</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>char**</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_BADFAXLINES</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint32*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_BITSPERSAMPLE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint16*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_CLEANFAXDATA</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint16*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_COLORMAP</p> -</td> -<td width="8%"> - -<p>3</p> -</td> -<td width="23%"> - -<p>uint16**</p> -</td> -<td width="17%"> - -<p>1<<BitsPerSample arrays</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_COMPRESSION</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint16*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_CONSECUTIVEBADFAXLINES</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint32*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_COPYRIGHT</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>char**</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_DATATYPE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint16*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_DATETIME</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>char**</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_DOCUMENTNAME</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>char**</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_DOTRANGE</p> -</td> -<td width="8%"> - -<p>2</p> -</td> -<td width="23%"> - -<p>uint16*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_EXTRASAMPLES</p> -</td> -<td width="8%"> - -<p>2</p> -</td> -<td width="23%"> - -<p>uint16*,uint16**</p> -</td> -<td width="17%"> - -<p>count & types array</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_FAXFILLFUNC</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>TIFFFaxFillFunc*</p> -</td> -<td width="17%"> - -<p>G3/G4 compression pseudo-tag</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_FAXMODE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>int*</p> -</td> -<td width="17%"> - -<p>G3/G4 compression pseudo-tag</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_FILLORDER</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint16*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_GROUP3OPTIONS</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint32*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_GROUP4OPTIONS</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint32*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_HALFTONEHINTS</p> -</td> -<td width="8%"> - -<p>2</p> -</td> -<td width="23%"> - -<p>uint16*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_HOSTCOMPUTER</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>char**</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_ICCPROFILE</p> -</td> -<td width="8%"> - -<p>2</p> -</td> -<td width="23%"> - -<p>uint32*,void**</p> -</td> -<td width="17%"> - -<p>count, profile data</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_IMAGEDEPTH</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint32*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_IMAGEDESCRIPTION</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>char**</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_IMAGELENGTH</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint32*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_IMAGEWIDTH</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint32*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_INKNAMES</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>char**</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_INKSET</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint16*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_JPEGCOLORMODE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>int*</p> -</td> -<td width="17%"> - -<p>JPEG pseudo-tag</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_JPEGQUALITY</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>int*</p> -</td> -<td width="17%"> - -<p>JPEG pseudo-tag</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_JPEGTABLES</p> -</td> -<td width="8%"> - -<p>2</p> -</td> -<td width="23%"> - -<p>uint32*,void**</p> -</td> -<td width="17%"> - -<p>count & tables</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_JPEGTABLESMODE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>int*</p> -</td> -<td width="17%"> - -<p>JPEG pseudo-tag</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_MAKE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>char**</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_MATTEING</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint16*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_MAXSAMPLEVALUE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint16*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_MINSAMPLEVALUE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint16*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_MODEL</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>char**</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_ORIENTATION</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint16*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_PAGENAME</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>char**</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_PAGENUMBER</p> -</td> -<td width="8%"> - -<p>2</p> -</td> -<td width="23%"> - -<p>uint16*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_PHOTOMETRIC</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint16*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_PHOTOSHOP</p> -</td> -<td width="8%"> - -<p>2</p> -</td> -<td width="23%"> - -<p>uint32*,void**</p> -</td> -<td width="17%"> - -<p>count, data</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_PLANARCONFIG</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint16*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_PREDICTOR</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint16*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_PRIMARYCHROMATICITIES</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>float**</p> -</td> -<td width="17%"> - -<p>6-entry array</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_REFERENCEBLACKWHITE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>float**</p> -</td> -<td width="17%"> - -<p>2*SamplesPerPixel array</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_RESOLUTIONUNIT</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint16*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_RICHTIFFIPTC</p> -</td> -<td width="8%"> - -<p>2</p> -</td> -<td width="23%"> - -<p>uint32*,void**</p> -</td> -<td width="17%"> - -<p>count, data</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_ROWSPERSTRIP</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint32*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_SAMPLEFORMAT</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint16*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_SAMPLESPERPIXEL</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint16*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_SMAXSAMPLEVALUE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>double*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_SMINSAMPLEVALUE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>double*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_SOFTWARE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>char**</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_STONITS</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>double**</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_STRIPBYTECOUNTS</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint32**</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_STRIPOFFSETS</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint32**</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_SUBFILETYPE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint32*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_SUBIFD</p> -</td> -<td width="8%"> - -<p>2</p> -</td> -<td width="23%"> - -<p>uint16*,uint32**</p> -</td> -<td width="17%"> - -<p>count & offsets array</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_TARGETPRINTER</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>char**</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_THRESHHOLDING</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint16*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_TILEBYTECOUNTS</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint32**</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_TILEDEPTH</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint32*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_TILELENGTH</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint32*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_TILEOFFSETS</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint32**</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_TILEWIDTH</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint32*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_TRANSFERFUNCTION</p> -</td> -<td width="8%"> - -<p>1 or 3†</p> -</td> -<td width="23%"></td> -<td width="17%"> - -<p>uint16**1<<BitsPerSample entry arrays</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_WHITEPOINT</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>float**</p> -</td> -<td width="17%"> - -<p>2-entry array</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_XMLPACKET</p> -</td> -<td width="8%"> - -<p>2</p> -</td> -<td width="23%"> - -<p>uint32*,void**</p> -</td> -<td width="17%"> - -<p>count, data</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_XPOSITION</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>float*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_XRESOLUTION</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>float*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_YCBCRCOEFFICIENTS</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>float**</p> -</td> -<td width="17%"> - -<p>3-entry array</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_YCBCRPOSITIONING</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>uint16*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_YCBCRSUBSAMPLING</p> -</td> -<td width="8%"> - -<p>2</p> -</td> -<td width="23%"> - -<p>uint16*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_YPOSITION</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>float*</p> -</td> -<td width="17%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_YRESOLUTION</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="23%"> - -<p>float*‡</p> -</td> -<td width="17%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>† If <i>SamplesPerPixel</i> is one, then a single -array is returned; otherwise three arrays are returned.<br> -‡ The contents of this field are quite complex. See -<i>The ICC Profile Format Specification</i>, Annex B.3 -"Embedding ICC Profiles in TIFF Files" (available -at http://www.color.org) for an explanation.</p> -</td> -</table> -<a name="AUTOREGISTERED TAGS"></a> -<h2>AUTOREGISTERED TAGS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>If you can’t find the tag in the table above that -means this is unsupported tag. But you still be able to read -it’s value if you know the data type of that tag. For -example, if you want to read the LONG value from the tag -33424 and ASCII string from the tag 36867 you can use the -following code:</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>uint16 count; -void *data; - -TIFFGetField(tiff, 33424, &count, &data); -printf("Tag %d: %d, count %d0, 33424, *(uint32 *)data, count); -TIFFGetField(tiff, 36867, &count, &data); -printf("Tag %d: %s, count %d0, 36867, (char *)data, count); -</pre> -</td> -</table> -<!-- INDENTATION --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>is not supported by <b>libtiff(3TIFF),</b> library</p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>1 is returned if the tag is defined in the current -directory; otherwise a 0 is returned.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>All error messages are directed to the -<b>TIFFError</b>(3TIFF) routine.</p> -<!-- INDENTATION --> -<p><b>Unknown field, tag 0x%x</b>. An unknown tag was -supplied.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>TIFFOpen</b>(3TIFF), <b>TIFFSetField</b>(3TIFF), -<b>TIFFSetDirectory</b>(3TIFF), -<b>TIFFReadDirectory</b>(3TIFF), -<b>TIFFWriteDirectory</b>(3TIFF) <b>libtiff</b>(3TIFF),</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFOpen.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFOpen.3tiff.html deleted file mode 100644 index 6bc85d8..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFOpen.3tiff.html +++ /dev/null @@ -1,421 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:15 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFOpen</title> -</head> -<body> - -<h1 align=center>TIFFOpen</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#BYTE ORDER">BYTE ORDER</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFOpen, TIFFFdOpen, TIFFClientOpen − open a -<small>TIFF</small> file for reading or writing</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>TIFF* TIFFOpen(const char *</b><i>filename</i><b>, -const char *</b><i>mode</i><b>)<br> -TIFF* TIFFFdOpen(const int</b> <i>fd</i><b>, const char -*</b><i>filename</i><b>, const char -*</b><i>mode</i><b>)</b></p> -<!-- INDENTATION --> -<p><b>typedef tsize_t (*TIFFReadWriteProc)(thandle_t, -tdata_t, tsize_t);<br> -typedef toff_t (*TIFFSeekProc)(thandle_t, toff_t, int);<br> -typedef int (*TIFFCloseProc)(thandle_t);<br> -typedef toff_t (*TIFFSizeProc)(thandle_t);<br> -typedef int (*TIFFMapFileProc)(thandle_t, tdata_t*, -toff_t*);<br> -typedef void (*TIFFUnmapFileProc)(thandle_t, tdata_t, -toff_t);</b></p> -<!-- INDENTATION --> -<p><b>TIFF* TIFFClientOpen(const char -*</b><i>filename</i><b>, const char *</b><i>mode</i><b>, -thandle_t</b> <i>clientdata</i><b>, TIFFReadWriteProc</b> -<i>readproc</i><b>, TIFFReadWriteProc</b> -<i>writeproc</i><b>, TIFFSeekProc</b> <i>seekproc</i><b>, -TIFFCloseProc</b> <i>closeproc</i><b>, TIFFSizeProc</b> -<i>sizeproc</i><b>, TIFFMapFileProc</b> <i>mapproc</i><b>, -TIFFUnmapFileProc</b> <i>unmapproc</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFOpen</i> opens a <small>TIFF</small> file whose -name is <i>filename</i> and returns a handle to be used in -subsequent calls to routines in <i>libtiff</i>. If the open -operation fails, then zero is returned. The <i>mode</i> -parameter specifies if the file is to be opened for reading -(‘‘r’’), writing -(‘‘w’’), or appending -(‘‘a’’) and, optionally, whether to -override certain default aspects of library operation (see -below). When a file is opened for appending, existing data -will not be touched; instead new data will be written as -additional subfiles. If an existing file is opened for -writing, all previous data is overwritten.</p> -<!-- INDENTATION --> -<p>If a file is opened for reading, the first -<small>TIFF</small> directory in the file is automatically -read (also see <i>TIFFSetDirectory</i>(3TIFF) for reading -directories other than the first). If a file is opened for -writing or appending, a default directory is automatically -created for writing subsequent data. This directory has all -the default values specified in <small>TIFF</small> Revision -6.0: <i>BitsPerSample</i>=1, <i>ThreshHolding</i>=bilevel -art scan, <i>FillOrder</i>=1 (most significant bit of each -data byte is filled first), <i>Orientation</i>=1 (the 0th -row represents the visual top of the image, and the 0th -column represents the visual left hand side), -<i>SamplesPerPixel</i>=1, <i>RowsPerStrip</i>=infinity, -<i>ResolutionUnit</i>=2 (inches), and <i>Compression</i>=1 -(no compression). To alter these values, or to define values -for additional fields, <i>TIFFSetField</i>(3TIFF) must be -used.</p> -<!-- INDENTATION --> -<p><i>TIFFFdOpen</i> is like <i>TIFFOpen</i> except that it -opens a <small>TIFF</small> file given an open file -descriptor <i>fd</i>. The file’s name and mode must -reflect that of the open descriptor. The object associated -with the file descriptor <b>must support random -access</b>.</p> -<!-- INDENTATION --> -<p><i>TIFFClientOpen</i> is like <i>TIFFOpen</i> except that -the caller supplies a collection of functions that the -library will use to do <small>UNIX</small> -like I/O -operations. The <i>readproc</i> and <i>writeproc</i> are -called to read and write data at the current file position. -<i>seekproc</i> is called to change the current file -position a la <i>lseek</i>(2). <i>closeproc</i> is invoked -to release any resources associated with an open file. -<i>sizeproc</i> is invoked to obtain the size in bytes of a -file. <i>mapproc</i> and <i>unmapproc</i> are called to map -and unmap a file’s contents in memory; c.f. -<i>mmap</i>(2) and <i>munmap</i>(2). The <i>clientdata</i> -parameter is an opaque ‘‘handle’’ -passed to the client-specified routines passed as parameters -to <i>TIFFClientOpen</i>.</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The open mode parameter can include the following flags -in addition to the ‘‘r’’, -‘‘w’’, and -‘‘a’’ flags. Note however that -option flags must follow the read-write-append -specification.</p> -</td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="2%"> - -<p><b>l</b></p> -</td> -<td width="6%"></td> -<td width="80%"> - -<p>When creating a new file force information be written -with Little-Endian byte order (but see below). By default -the library will create new files using the native -<small>CPU</small> byte order.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="2%"> - -<p><b>b</b></p> -</td> -<td width="6%"></td> -<td width="80%"> - -<p>When creating a new file force information be written -with Big-Endian byte order (but see below). By default the -library will create new files using the native -<small>CPU</small> byte order.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="2%"> - -<p><b>L</b></p> -</td> -<td width="6%"></td> -<td width="80%"> - -<p>Force image data that is read or written to be treated -with bits filled from Least Significant Bit ( -<small>LSB</small> ) to Most Significant Bit ( -<small>MSB</small> ). Note that this is the opposite to the -way the library has worked from its inception.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="2%"> - -<p><b>B</b></p> -</td> -<td width="6%"></td> -<td width="80%"> - -<p>Force image data that is read or written to be treated -with bits filled from Most Significant Bit ( -<small>MSB</small> ) to Least Significant Bit ( -<small>LSB</small> ); this is the default.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="2%"> - -<p><b>H</b></p> -</td> -<td width="6%"></td> -<td width="80%"> - -<p>Force image data that is read or written to be treated -with bits filled in the same order as the native -<small>CPU.</small></p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="2%"> - -<p><b>M</b></p> -</td> -<td width="6%"></td> -<td width="80%"> - -<p>Enable the use of memory-mapped files for images opened -read-only. If the underlying system does not support -memory-mapped files or if the specific image being opened -cannot be memory-mapped then the library will fallback to -using the normal system interface for reading information. -By default the library will attempt to use memory-mapped -files.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="2%"> - -<p><b>m</b></p> -</td> -<td width="6%"></td> -<td width="80%"> - -<p>Disable the use of memory-mapped files.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="2%"> - -<p><b>C</b></p> -</td> -<td width="6%"></td> -<td width="80%"> - -<p>Enable the use of ‘‘strip -chopping’’ when reading images that are -comprised of a single strip or tile of uncompressed data. -Strip chopping is a mechanism by which the library will -automatically convert the single-strip image to multiple -strips, each of which has about 8 Kilobytes of data. This -facility can be useful in reducing the amount of memory used -to read an image because the library normally reads each -strip in its entirety. Strip chopping does however alter the -apparent contents of the image because when an image is -divided into multiple strips it looks as though the -underlying file contains multiple separate strips. Finally, -note that default handling of strip chopping is a -compile-time configuration parameter. The default behaviour, -for backwards compatibility, is to enable strip -chopping.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="2%"> - -<p><b>c</b></p> -</td> -<td width="6%"></td> -<td width="80%"> - -<p>Disable the use of strip chopping when reading -images.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="2%"> - -<p><b>h</b></p> -</td> -<td width="6%"></td> -<td width="80%"> - -<p>Read TIFF header only, do not load the first image -directory. That could be useful in case of the broken first -directory. We can open the file and proceed to the other -directories.</p> -</td> -<td width="0%"> -</td> -</table> -<a name="BYTE ORDER"></a> -<h2>BYTE ORDER</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The <small>TIFF</small> specification (<b>all -versions</b>) states that compliant readers <i>must be -capable of reading images written in either byte order</i>. -Nonetheless some software that claims to support the reading -of <small>TIFF</small> images is incapable of reading images -in anything but the native <small>CPU</small> byte order on -which the software was written. (Especially notorious are -applications written to run on Intel-based machines.) By -default the library will create new files with the native -byte-order of the <small>CPU</small> on which the -application is run. This ensures optimal performance and is -portable to any application that conforms to the TIFF -specification. To force the library to use a specific -byte-order when creating a new file the -‘‘b’’ and -‘‘l’’ option flags may be included -in the call to open a file; for example, -‘‘wb’’ or -‘‘wl’’.</p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Upon successful completion <i>TIFFOpen</i>, -<i>TIFFFdOpen</i>, and <i>TIFFClientOpen</i> return a -<small>TIFF</small> pointer. Otherwise, NULL is -returned.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>All error messages are directed to the -<i>TIFFError</i>(3TIFF) routine. Likewise, warning messages -are directed to the <i>TIFFWarning</i>(3TIFF) routine.</p> -<!-- INDENTATION --> -<p><b>"%s": Bad mode</b>. The specified -<i>mode</i> parameter was not one of -‘‘r’’ (read), -‘‘w’’ (write), or -‘‘a’’ (append).</p> -<!-- INDENTATION --> -<p><b>%s: Cannot open</b>. <i>TIFFOpen</i>() was unable to -open the specified filename for read/writing.</p> -<!-- INDENTATION --> -<p><b>Cannot read TIFF header</b>. An error occurred while -attempting to read the header information.</p> -<!-- INDENTATION --> -<p><b>Error writing TIFF header</b>. An error occurred while -writing the default header information for a new file.</p> -<!-- INDENTATION --> -<p><b>Not a TIFF file, bad magic number %d (0x%x)</b>. The -magic number in the header was not (hex) 0x4d4d or (hex) -0x4949.</p> -<!-- INDENTATION --> -<p><b>Not a TIFF file, bad version number %d (0x%x)</b>. The -version field in the header was not 42 (decimal).</p> -<!-- INDENTATION --> -<p><b>Cannot append to file that has opposite byte -ordering</b>. A file with a byte ordering opposite to the -native byte ordering of the current machine was opened for -appending (‘‘a’’). This is a -limitation of the library.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>libtiff</i>(3TIFF), <i>TIFFClose</i>(3TIFF)</p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFPrintDirectory.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFPrintDirectory.3tiff.html deleted file mode 100644 index a5f418a..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFPrintDirectory.3tiff.html +++ /dev/null @@ -1,225 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:15 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFPrintDirectory</title> -</head> -<body> - -<h1 align=center>TIFFPrintDirectory</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#NOTES">NOTES</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFPrintDirectory − print a description of a -<small>TIFF</small> directory</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>void TIFFPrintDirectory(TIFF *</b><i>tif</i><b>, FILE -*</b><i>fd</i><b>, long</b> <i>flags</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFPrintDirectory</i> prints a description of the -current directory in the specified <small>TIFF</small> file -to the standard I/O output stream <i>fd</i>. The -<i>flags</i> parameter is used to control the <i>level of -detail</i> of the printed information; it is a bit-or of the -flags defined in <b>tiffio.h</b>:</p></td> -</table> -<!-- TABS --> - -<p>#define TIFFPRINT_NONE 0x0 /* no extra info */</p> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="1%"> - -<p>#define</p> -</td> -<td width="30%"> - -<p>TIFFPRINT_STRIPS</p> -</td> -<td width="10%"> - -<p>0x1</p> -</td> -<td width="48%"> - -<p>/* strips/tiles info */</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="1%"> - -<p>#define</p> -</td> -<td width="30%"> - -<p>TIFFPRINT_CURVES</p> -</td> -<td width="10%"> - -<p>0x2</p> -</td> -<td width="48%"> - -<p>/* color/gray response curves */</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="1%"> - -<p>#define</p> -</td> -<td width="30%"> - -<p>TIFFPRINT_COLORMAP</p> -</td> -<td width="10%"> - -<p>0x4</p> -</td> -<td width="48%"> - -<p>/* colormap */</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="1%"> - -<p>#define</p> -</td> -<td width="30%"> - -<p>TIFFPRINT_JPEGQTABLES</p> -</td> -<td width="10%"> - -<p>0x100</p> -</td> -<td width="48%"> - -<p>/* JPEG Q matrices */</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="1%"> - -<p>#define</p> -</td> -<td width="30%"> - -<p>TIFFPRINT_JPEGACTABLES</p> -</td> -<td width="10%"> - -<p>0x200</p> -</td> -<td width="48%"> - -<p>/* JPEG AC tables */</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="1%"> - -<p>#define</p> -</td> -<td width="30%"> - -<p>TIFFPRINT_JPEGDCTABLES</p> -</td> -<td width="10%"> - -<p>0x200</p> -</td> -<td width="48%"> - -<p>/* JPEG DC tables */</p> -</td> -</table> -<a name="NOTES"></a> -<h2>NOTES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>In C++ the <i>flags</i> parameter defaults to 0.</p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>None.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>None.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>libtiff</i>(3TIFF), <i>TIFFOpen</i>(3TIFF), -<i>TIFFReadDirectory</i>(3TIFF), -<i>TIFFSetDirectory</i>(3TIFF)</p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFRGBAImage.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFRGBAImage.3tiff.html deleted file mode 100644 index 7bbee0f..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFRGBAImage.3tiff.html +++ /dev/null @@ -1,319 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:16 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFRGBAImage</title> -</head> -<body> - -<h1 align=center>TIFFRGBAImage</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#ALTERNATE RASTER FORMATS">ALTERNATE RASTER FORMATS</a><br> -<a href="#SIMULTANEOUS RASTER STORE AND DISPLAY">SIMULTANEOUS RASTER STORE AND DISPLAY</a><br> -<a href="#SUPPORTING ADDITIONAL TIFF FORMATS">SUPPORTING ADDITIONAL TIFF FORMATS</a><br> -<a href="#NOTES">NOTES</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFRGBAImageOK, TIFFRGBAImageBegin, TIFFRGBAImageGet, -TIFFRGBAImageEnd − read and decode an image into a -raster</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>typedef unsigned char TIFFRGBValue; typedef struct -_TIFFRGBAImage TIFFRGBAImage;</b></p> -<!-- INDENTATION --> -<p><b>int TIFFRGBAImageOK(TIFF *</b><i>tif</i><b>, char</b> -<i>emsg[1024]</i><b>)<br> -int TIFFRGBAImageBegin(TIFFRGBAImage *</b><i>img</i><b>, -TIFF*</b> <i>tif</i><b>, int</b> <i>stopOnError</i><b>, -char</b> <i>emsg[1024]</i><b>)<br> -int TIFFRGBAImageGet(TIFFRGBAImage *</b><i>img</i><b>, -uint32*</b> <i>raster</i><b>, uint32</b> <i>width</i> <b>, -uint32</b> <i>height</i><b>)<br> -void TIFFRGBAImageEnd(TIFFRGBAImage -*</b><i>img</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The routines described here provide a high-level -interface through which <small>TIFF</small> images may be -read into memory. Images may be strip- or tile-based and -have a variety of different characteristics: bits/sample, -samples/pixel, photometric, etc. Decoding state is -encapsulated in a <i>TIFFRGBAImage</i> structure making it -possible to capture state for multiple images and quickly -switch between them. The target raster format can be -customized to a particular application’s needs by -installing custom routines that manipulate image data -according to application requirements.</p> -<!-- INDENTATION --> -<p>The default usage for these routines is: check if an -image can be processed using <i>TIFFRGBAImageOK</i>, -construct a decoder state block using -<i>TIFFRGBAImageBegin</i>, read and decode an image into a -target raster using <i>TIFFRGBAImageGet</i>, and then -release resources using <i>TIFFRGBAImageEnd</i>. -<i>TIFFRGBAImageGet</i> can be called multiple times to -decode an image using different state parameters. If -multiple images are to be displayed and there is not enough -space for each of the decoded rasters, multiple state blocks -can be managed and then calls can be made to -<i>TIFFRGBAImageGet</i> as needed to display an image.</p> -<!-- INDENTATION --> -<p>The generated raster is assumed to be an array of -<i>width</i> times <i>height</i> 32-bit entries, where -<i>width</i> must be less than or equal to the width of the -image (<i>height</i> may be any non-zero size). If the -raster dimensions are smaller than the image, the image data -is cropped to the raster bounds. If the raster height is -greater than that of the image, then the image data are -placed in the lower part of the raster. (Note that the -raster is assume to be organized such that the pixel at -location (<i>x</i>,<i>y</i>) is -<i>raster</i>[<i>y</i>*<i>width</i>+<i>x</i>]; with the -raster origin in the <b>lower-left</b> hand corner.)</p> -<!-- INDENTATION --> -<p>Raster pixels are 8-bit packed red, green, blue, alpha -samples. The macros <i>TIFFGetR</i>, <i>TIFFGetG</i>, -<i>TIFFGetB</i>, and <i>TIFFGetA</i> should be used to -access individual samples. Images without Associated Alpha -matting information have a constant Alpha of 1.0 (255).</p> -<!-- INDENTATION --> -<p><i>TIFFRGBAImageGet</i> converts non-8-bit images by -scaling sample values. Palette, grayscale, bilevel, -<small>CMYK</small> , and YCbCr images are converted to -<small>RGB</small> transparently. Raster pixels are returned -uncorrected by any colorimetry information present in the -directory.</p> -<!-- INDENTATION --> -<p>The parameter <i>stopOnError</i> specifies how to act if -an error is encountered while reading the image. If -<i>stopOnError</i> is non-zero, then an error will terminate -the operation; otherwise <i>TIFFRGBAImageGet</i> will -continue processing data until all the possible data in the -image have been requested.</p> -</td> -</table> -<a name="ALTERNATE RASTER FORMATS"></a> -<h2>ALTERNATE RASTER FORMATS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>To use the core support for reading and processing -<small>TIFF</small> images, but write the resulting raster -data in a different format one need only override the -‘‘<i>put methods</i>’’ used to store -raster data. These methods are are defined in the -<i>TIFFRGBAImage</i> structure and initially setup by -<i>TIFFRGBAImageBegin</i> to point to routines that pack -raster data in the default <small>ABGR</small> pixel format. -Two different routines are used according to the physical -organization of the image data in the file: -<i>PlanarConfiguration</i>=1 (packed samples), and -<i>PlanarConfiguration</i>=2 (separated samples). Note that -this mechanism can be used to transform the data before -storing it in the raster. For example one can convert data -to colormap indices for display on a colormap display.</p> -</td> -</table> -<a name="SIMULTANEOUS RASTER STORE AND DISPLAY"></a> -<h2>SIMULTANEOUS RASTER STORE AND DISPLAY</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>It is simple to display an image as it is being read into -memory by overriding the put methods as described above for -supporting alternate raster formats. Simply keep a reference -to the default put methods setup by -<i>TIFFRGBAImageBegin</i> and then invoke them before or -after each display operation. For example, the -<i>tiffgt</i>(1) utility uses the following put method to -update the display as the raster is being filled:</p> -<!-- INDENTATION --> -<pre>static void -putContigAndDraw(TIFFRGBAImage* img, uint32* raster, - uint32 x, uint32 y, uint32 w, uint32 h, - int32 fromskew, int32 toskew, - unsigned char* cp) -{ - (*putContig)(img, raster, x, y, w, h, fromskew, toskew, cp); - if (x+w == width) { - w = width; - if (img->orientation == ORIENTATION_TOPLEFT) - lrectwrite(0, y-(h-1), w-1, y, raster-x-(h-1)*w); - else - lrectwrite(0, y, w-1, y+h-1, raster); - } -} -</pre> -<!-- INDENTATION --> -<p>(the original routine provided by the library is saved in -the variable <i>putContig</i>.)</p> -</td> -</table> -<a name="SUPPORTING ADDITIONAL TIFF FORMATS"></a> -<h2>SUPPORTING ADDITIONAL TIFF FORMATS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The <i>TIFFRGBAImage</i> routines support the most -commonly encountered flavors of <small>TIFF.</small> It is -possible to extend this support by overriding the -‘‘<i>get method</i>’’ invoked by -<i>TIFFRGBAImageGet</i> to read <small>TIFF</small> image -data. Details of doing this are a bit involved, it is best -to make a copy of an existing get method and modify it to -suit the needs of an application.</p> -</td> -</table> -<a name="NOTES"></a> -<h2>NOTES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Samples must be either 1, 2, 4, 8, or 16 bits. -Colorimetric samples/pixel must be either 1, 3, or 4 (i.e. -<i>SamplesPerPixel</i> minus <i>ExtraSamples</i>).</p> -<!-- INDENTATION --> -<p>Palette image colormaps that appear to be incorrectly -written as 8-bit values are automatically scaled to -16-bits.</p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>All routines return 1 if the operation was successful. -Otherwise, 0 is returned if an error was encountered and -<i>stopOnError</i> is zero.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>All error messages are directed to the -<i>TIFFError</i>(3TIFF) routine.</p> -<!-- INDENTATION --> -<p><b>Sorry, can not handle %d-bit pictures</b>. The image -had <i>BitsPerSample</i> other than 1, 2, 4, 8, or 16.</p> -<!-- INDENTATION --> -<p><b>Sorry, can not handle %d-channel images</b>. The image -had <i>SamplesPerPixel</i> other than 1, 3, or 4.</p> -<!-- INDENTATION --> -<p><b>Missing needed "PhotometricInterpretation" -tag</b>. The image did not have a tag that describes how to -display the data.</p> -<!-- INDENTATION --> -<p><b>No "PhotometricInterpretation" tag, assuming -RGB</b>. The image was missing a tag that describes how to -display it, but because it has 3 or 4 samples/pixel, it is -assumed to be <small>RGB.</small></p> -<!-- INDENTATION --> -<p><b>No "PhotometricInterpretation" tag, assuming -min-is-black</b>. The image was missing a tag that describes -how to display it, but because it has 1 sample/pixel, it is -assumed to be a grayscale or bilevel image.</p> -<!-- INDENTATION --> -<p><b>No space for photometric conversion table</b>. There -was insufficient memory for a table used to convert image -samples to 8-bit <small>RGB.</small></p> -<!-- INDENTATION --> -<p><b>Missing required "Colormap" tag</b>. A -Palette image did not have a required <i>Colormap</i> -tag.</p> -<!-- INDENTATION --> -<p><b>No space for tile buffer</b>. There was insufficient -memory to allocate an i/o buffer.</p> -<!-- INDENTATION --> -<p><b>No space for strip buffer</b>. There was insufficient -memory to allocate an i/o buffer.</p> -<!-- INDENTATION --> -<p><b>Can not handle format</b>. The image has a format -(combination of <i>BitsPerSample</i>, -<i>SamplesPerPixel</i>, and -<i>PhotometricInterpretation</i>) that can not be -handled.</p> -<!-- INDENTATION --> -<p><b>No space for B&W mapping table</b>. There was -insufficient memory to allocate a table used to map -grayscale data to <small>RGB.</small></p> -<!-- INDENTATION --> -<p><b>No space for Palette mapping table</b>. There was -insufficient memory to allocate a table used to map data to -8-bit <small>RGB.</small></p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>TIFFOpen</b>(3TIFF), <b>TIFFReadRGBAImage</b>(3TIFF), -<b>TIFFReadRGBAImageOriented</b>(3TIFF), -<b>TIFFReadRGBAStrip</b>(3TIFF), -<b>TIFFReadRGBATile</b>(3TIFF), <b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFReadDirectory.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFReadDirectory.3tiff.html deleted file mode 100644 index 5bb828e..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFReadDirectory.3tiff.html +++ /dev/null @@ -1,218 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:16 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFReadDirectory</title> -</head> -<body> - -<h1 align=center>TIFFReadDirectory</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#NOTES">NOTES</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>TIFFReadDirectory − get the contents of the -next directory in an open</big> TIFF <big>file</big></p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big><b>#include <tiffio.h></b></big></p> -<!-- INDENTATION --> -<p><big><b>int TIFFReadDirectory(TIFF -*</b><i>tif</i><b>)</b></big></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>Read the next directory in the specified file and -make it the current directory. Applications only need to -call <i>TIFFReadDirectory</i> to read multiple subfiles in a -single</big> TIFF <big>file— the first directory in a -file is automatically read when <i>TIFFOpen</i> is -called.</big></p> -</td> -</table> -<a name="NOTES"></a> -<h2>NOTES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>If the library is compiled with</big> -STRIPCHOP_SUPPORT <big>enabled, then images that have a -single uncompressed strip or tile of data are automatically -treated as if they were made up of multiple strips or tiles -of approximately 8 kilobytes each. This operation is done -only in-memory; it does not alter the contents of the file. -However, the construction of the ‘‘chopped -strips’’ is visible to the application through -the number of strips [tiles] returned by -<i>TIFFNumberOfStrips</i> -[<i>TIFFNumberOfTiles</i>].</big></p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>If the next directory was successfully read, 1 is -returned. Otherwise, 0 is returned if an error was -encountered, or if there are no more directories to be -read.</big></p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>All error messages are directed to the -<i>TIFFError</i>(3TIFF) routine. All warning messages are -directed to the <i>TIFFWarning</i>(3TIFF) routine.</big></p> -<!-- INDENTATION --> -<p><big><b>Seek error accessing TIFF directory</b>. An error -occurred while positioning to the location of the -directory.</big></p> -<!-- INDENTATION --> -<p><big><b>Wrong data type %d for field "%s"</b>. -The tag entry in the directory had an incorrect data type. -For example, an <i>ImageDescription</i> tag with a</big> -SHORT <big>data type.</big></p> -<!-- INDENTATION --> -<p><big><b>TIFF directory is missing required "%s" -field</b>. The specified tag is required to be present by -the</big> TIFF <big>5.0 specification, but is missing. The -directory is (usually) unusable.</big></p> -<!-- INDENTATION --> -<p><big><b>%s: Rational with zero denominator</b>. A -directory tag has a</big> RATIONAL <big>value whose -denominator is zero.</big></p> -<!-- INDENTATION --> -<p><big><b>Incorrect count %d for field "%s" (%lu, -expecting %lu); tag ignored</b>. The specified tag’s -count field is bad. For example, a count other than 1 for a -<i>SubFileType</i> tag.</big></p> -<!-- INDENTATION --> -<p><big><b>Cannot handle different per-sample values for -field "%s"</b>. The tag has <i>SamplesPerPixel</i> -values and they are not all the same; e.g. -<i>BitsPerSample</i>. The library is unable to handle images -of this sort.</big></p> -<!-- INDENTATION --> -<p><big><b>Count mismatch for field "%s"; -expecting %d, got %d</b>. The count field in a tag does not -agree with the number expected by the library. This should -never happen, so if it does, the library refuses to read the -directory.</big></p> -<!-- INDENTATION --> -<p><big><b>Invalid TIFF directory; tags are not sorted in -ascending order</b>. The directory tags are not properly -sorted as specified in the</big> TIFF <big>5.0 -specification. This error is not fatal.</big></p> -<!-- INDENTATION --> -<p><big><b>Ignoring unknown field with tag %d (0x%x)</b>. An -unknown tag was encountered in the directory; the library -ignores all such tags.</big></p> -<!-- INDENTATION --> -<p><big><b>TIFF directory is missing requred -"ImageLength" field</b>. The image violates the -specification by not having a necessary field. There is no -way for the library to recover from this error.</big></p> -<!-- INDENTATION --> -<p><big><b>TIFF directory is missing requred -"PlanarConfig" field</b>. The image violates the -specification by not having a necessary field. There is no -way for the library to recover from this error.</big></p> -<!-- INDENTATION --> -<p><big><b>TIFF directory is missing requred -"StripOffsets" field</b>. The image has multiple -strips, but is missing the tag that specifies the file -offset to each strip of data. There is no way for the -library to recover from this error.</big></p> -<!-- INDENTATION --> -<p><big><b>TIFF directory is missing requred -"TileOffsets" field</b>. The image has multiple -tiles, but is missing the tag that specifies the file offset -to each tile of data. There is no way for the library to -recover from this error.</big></p> -<!-- INDENTATION --> -<p><big><b>TIFF directory is missing required -"StripByteCounts" field</b>. The image has -multiple strips, but is missing the tag that specifies the -size of each strip of data. There is no way for the library -to recover from this error.</big></p> -<!-- INDENTATION --> -<p><big><b>TIFF directory is missing required -"StripByteCounts" field, calculating from -imagelength</b>. The image violates the specification by not -having a necessary field. However, when the image is -comprised of only one strip or tile, the library will -estimate the missing value based on the file size.</big></p> -<!-- INDENTATION --> -<p><big><b>Bogus "StripByteCounts" field, ignoring -and calculating from imagelength</b>. Certain vendors -violate the specification by writing zero for the -StripByteCounts tag when they want to leave the value -unspecified. If the image has a single strip, the library -will estimate the missing value based on the file -size.</big></p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big><b>TIFFOpen</b>(3TIFF), -<b>TIFFWriteDirectory</b>(3TIFF), -<b>TIFFSetDirectory</b>(3TIFF), -<b>TIFFSetSubDirectory</b>(3TIFF), -<b>libtiff</b>(3TIFF)</big></p> -<!-- INDENTATION --> -<p><big>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></big></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFReadEncodedStrip.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFReadEncodedStrip.3tiff.html deleted file mode 100644 index 39d411d..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFReadEncodedStrip.3tiff.html +++ /dev/null @@ -1,133 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:16 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFReadEncodedStrip</title> -</head> -<body> - -<h1 align=center>TIFFReadEncodedStrip</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#NOTES">NOTES</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>TIFFReadEncodedStrip − read and decode a strip -of data from an open</big> TIFF <big>file</big></p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big><b>#include <tiffio.h></b></big></p> -<!-- INDENTATION --> -<p><big><b>tsize_t TIFFReadEncodedStrip(TIFF -*</b><i>tif</i><b>, tstrip_t</b> <i>strip</i><b>, -tdata_t</b> <i>buf</i><b>, tsize_t</b> -<i>size</i><b>)</b></big></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>Read the specified strip of data and place up to -<i>size</i> bytes of decompressed information in the (user -supplied) data buffer.</big></p> -</td> -</table> -<a name="NOTES"></a> -<h2>NOTES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>The value of <i>strip</i> is a ‘‘raw -strip number.’’ That is, the caller must take -into account whether or not the data are organized in -separate planes (<i>PlanarConfiguration</i>=2). To read a -full strip of data the data buffer should typically be at -least as large as the number returned by -<b>TIFFStripSize</b>(3TIFF). If the -1 passed in <i>size</i> -parameter, the whole strip will be read. You should be sure -you have enough space allocated for the buffer.</big></p> -<!-- INDENTATION --> -<p><big>The library attempts to hide bit- and byte-ordering -differences between the image and the native machine by -converting data to the native machine order. Bit reversal is -done if the <i>FillOrder</i> tag is opposite to the native -machine bit order. 16- and 32-bit samples are automatically -byte-swapped if the file was written with a byte order -opposite to the native machine byte order,</big></p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>The actual number of bytes of data that were placed -in <i>buf</i> is returned; <i>TIFFReadEncodedStrip</i> -returns −1 if an error was encountered.</big></p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>All error messages are directed to the -<b>TIFFError</b>(3TIFF) routine.</big></p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big><b>TIFFOpen</b>(3TIFF), -<b>TIFFReadRawStrip</b>(3TIFF), -<b>TIFFReadScanline</b>(3TIFF), -<b>libtiff</b>(3TIFF)</big></p> -<!-- INDENTATION --> -<p><big>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></big></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFReadEncodedTile.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFReadEncodedTile.3tiff.html deleted file mode 100644 index 752b1ea..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFReadEncodedTile.3tiff.html +++ /dev/null @@ -1,130 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:16 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFReadEncodedTile</title> -</head> -<body> - -<h1 align=center>TIFFReadEncodedTile</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#NOTES">NOTES</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFReadEncodedTile − read and decode a tile of -data from an open <small>TIFF</small> file</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>int TIFFReadEncodedTile(TIFF *</b><i>tif</i><b>, -ttile_t</b> <i>tile</i><b>, tdata_t</b> <i>buf</i><b>, -tsize_t</b> <i>size</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Read the specified tile of data and place up to -<i>size</i> bytes of decompressed information in the (user -supplied) data buffer.</p> -</td> -</table> -<a name="NOTES"></a> -<h2>NOTES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The value of <i>tile</i> is a ‘‘raw tile -number.’’ That is, the caller must take into -account whether or not the data are organized in separate -planes (<i>PlanarConfiguration</i>=2). -<i>TIFFComputeTile</i> automatically does this when -converting an (x,y,z,sample) coordinate quadruple to a tile -number. To read a full tile of data the data buffer should -be at least as large as the value returned by -<i>TIFFTileSize</i>.</p> -<!-- INDENTATION --> -<p>The library attempts to hide bit- and byte-ordering -differences between the image and the native machine by -converting data to the native machine order. Bit reversal is -done if the <i>FillOrder</i> tag is opposite to the native -machine bit order. 16- and 32-bit samples are automatically -byte-swapped if the file was written with a byte order -opposite to the native machine byte order,</p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The actual number of bytes of data that were placed in -<i>buf</i> is returned; <i>TIFFReadEncodedTile</i> returns -−1 if an error was encountered.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>All error messages are directed to the -<b>TIFFError</b>(3TIFF) routine.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>TIFFOpen</b>(3TIFF), <b>TIFFReadRawTile</b>(3TIFF), -<b>TIFFReadTile</b>(3TIFF), <b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFReadRGBAImage.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFReadRGBAImage.3tiff.html deleted file mode 100644 index 165284e..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFReadRGBAImage.3tiff.html +++ /dev/null @@ -1,301 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:16 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFReadRGBAImage</title> -</head> -<body> - -<h1 align=center>TIFFReadRGBAImage</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#NOTES">NOTES</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFReadRGBAImage, TIFFReadRGBAImageOriented − read -and decode an image into a fixed-format raster</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>#define TIFFGetR(abgr) ((abgr) & 0xff)<br> -#define TIFFGetG(abgr) (((abgr) >> 8) & 0xff)<br> -#define TIFFGetB(abgr) (((abgr) >> 16) & 0xff)<br> -#define TIFFGetA(abgr) (((abgr) >> 24) & -0xff)</b></p> -<!-- INDENTATION --> -<p><b>int TIFFReadRGBAImage(TIFF *</b><i>tif</i><b>, -uint32</b> <i>width</i><b>, uint32</b> <i>height</i><b>, -uint32 *</b><i>raster</i><b>, int</b> -<i>stopOnError</i><b>)<br> -int TIFFReadRGBAImageOriented(TIFF *</b><i>tif</i><b>, -uint32</b> <i>width</i><b>, uint32</b> <i>height</i><b>, -uint32 *</b><i>raster</i><b>, int</b> <i>orientation</i><b>, -int</b> <i>stopOnError</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFReadRGBAImage</i> reads a strip- or tile-based -image into memory, storing the result in the user supplied -<i>raster</i>. The raster is assumed to be an array of -<i>width</i> times <i>height</i> 32-bit entries, where -<i>width</i> must be less than or equal to the width of the -image (<i>height</i> may be any non-zero size). If the -raster dimensions are smaller than the image, the image data -is cropped to the raster bounds. If the raster height is -greater than that of the image, then the image data are -placed in the lower part of the raster. (Note that the -raster is assume to be organized such that the pixel at -location (<i>x</i>,<i>y</i>) is -<i>raster</i>[<i>y</i>*<i>width</i>+<i>x</i>]; with the -raster origin in the lower-left hand corner.)</p> -<!-- INDENTATION --> -<p><i>TIFFReadRGBAImageOriented</i> works like -<i>TIFFReadRGBAImage</i> with except of that user can -specify the raster origin position with the -<i>orientation</i> parameter. Four orientations -supported:</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>ORIENTATION_TOPLEFT</b></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>origin in top-left corner,</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>ORIENTATION_TOPRIGHT</b></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>origin in top-right corner,</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>ORIENTATION_BOTLEFT</b></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>origin in bottom-left corner and</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>ORIENTATION_BOTRIGHT</b></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>origin in bottom-right corner.</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>If you choose <b>ORIENTATION_BOTLEFT</b> result will be -the same as returned by the <i>TIFFReadRGBAImage.</i></p> -<!-- INDENTATION --> -<p>Raster pixels are 8-bit packed red, green, blue, alpha -samples. The macros <i>TIFFGetR</i>, <i>TIFFGetG</i>, -<i>TIFFGetB</i>, and <i>TIFFGetA</i> should be used to -access individual samples. Images without Associated Alpha -matting information have a constant Alpha of 1.0 (255).</p> -<!-- INDENTATION --> -<p><i>TIFFReadRGBAImage</i> converts non-8-bit images by -scaling sample values. Palette, grayscale, bilevel, -<small>CMYK</small> , and YCbCr images are converted to -<small>RGB</small> transparently. Raster pixels are returned -uncorrected by any colorimetry information present in the -directory.</p> -<!-- INDENTATION --> -<p>The paramater <i>stopOnError</i> specifies how to act if -an error is encountered while reading the image. If -<i>stopOnError</i> is non-zero, then an error will terminate -the operation; otherwise <i>TIFFReadRGBAImage</i> will -continue processing data until all the possible data in the -image have been requested.</p> -</td> -</table> -<a name="NOTES"></a> -<h2>NOTES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>In C++ the <i>stopOnError</i> parameter defaults to -0.</p> -<!-- INDENTATION --> -<p>Samples must be either 1, 2, 4, 8, or 16 bits. -Colorimetric samples/pixel must be either 1, 3, or 4 (i.e. -<i>SamplesPerPixel</i> minus <i>ExtraSamples</i>).</p> -<!-- INDENTATION --> -<p>Palettte image colormaps that appear to be incorrectly -written as 8-bit values are automatically scaled to -16-bits.</p> -<!-- INDENTATION --> -<p><i>TIFFReadRGBAImage</i> is just a wrapper around the -more general <i>TIFFRGBAImage</i>(3TIFF) facilities.</p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>1 is returned if the image was successfully read and -converted. Otherwise, 0 is returned if an error was -encountered and <i>stopOnError</i> is zero.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>All error messages are directed to the -<i>TIFFError</i>(3TIFF) routine.</p> -<!-- INDENTATION --> -<p><b>Sorry, can not handle %d-bit pictures</b>. The image -had <i>BitsPerSample</i> other than 1, 2, 4, 8, or 16.</p> -<!-- INDENTATION --> -<p><b>Sorry, can not handle %d-channel images</b>. The image -had <i>SamplesPerPixel</i> other than 1, 3, or 4.</p> -<!-- INDENTATION --> -<p><b>Missing needed "PhotometricInterpretation" -tag</b>. The image did not have a tag that describes how to -display the data.</p> -<!-- INDENTATION --> -<p><b>No "PhotometricInterpretation" tag, assuming -RGB</b>. The image was missing a tag that describes how to -display it, but because it has 3 or 4 samples/pixel, it is -assumed to be <small>RGB.</small></p> -<!-- INDENTATION --> -<p><b>No "PhotometricInterpretation" tag, assuming -min-is-black</b>. The image was missing a tag that describes -how to display it, but because it has 1 sample/pixel, it is -assumed to be a grayscale or bilevel image.</p> -<!-- INDENTATION --> -<p><b>No space for photometric conversion table</b>. There -was insufficient memory for a table used to convert image -samples to 8-bit <small>RGB.</small></p> -<!-- INDENTATION --> -<p><b>Missing required "Colormap" tag</b>. A -Palette image did not have a required <i>Colormap</i> -tag.</p> -<!-- INDENTATION --> -<p><b>No space for tile buffer</b>. There was insufficient -memory to allocate an i/o buffer.</p> -<!-- INDENTATION --> -<p><b>No space for strip buffer</b>. There was insufficient -memory to allocate an i/o buffer.</p> -<!-- INDENTATION --> -<p><b>Can not handle format</b>. The image has a format -(combination of <i>BitsPerSample</i>, -<i>SamplesPerPixel</i>, and -<i>PhotometricInterpretation</i>) that -<i>TIFFReadRGBAImage</i> can not handle.</p> -<!-- INDENTATION --> -<p><b>No space for B&W mapping table</b>. There was -insufficient memory to allocate a table used to map -grayscale data to <small>RGB.</small></p> -<!-- INDENTATION --> -<p><b>No space for Palette mapping table</b>. There was -insufficient memory to allocate a table used to map data to -8-bit <small>RGB.</small></p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>TIFFOpen</b>(3TIFF), <b>TIFFRGBAImage</b>(3TIFF), -<b>TIFFReadRGBAStrip</b>(3TIFF), -<b>TIFFReadRGBATile</b>(3TIFF), <b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFReadRGBAStrip.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFReadRGBAStrip.3tiff.html deleted file mode 100644 index df09f64..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFReadRGBAStrip.3tiff.html +++ /dev/null @@ -1,208 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:16 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFReadRGBAStrip</title> -</head> -<body> - -<h1 align=center>TIFFReadRGBAStrip</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#NOTES">NOTES</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFReadRGBAStrip − read and decode an image strip -into a fixed-format raster</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>#define TIFFGetR(abgr) ((abgr) & 0xff)<br> -#define TIFFGetG(abgr) (((abgr) >> 8) & 0xff)<br> -#define TIFFGetB(abgr) (((abgr) >> 16) & 0xff)<br> -#define TIFFGetA(abgr) (((abgr) >> 24) & -0xff)</b></p> -<!-- INDENTATION --> -<p><b>int TIFFReadRGBAStrip(TIFF *</b><i>tif</i><b>, -uint32</b> <i>row</i><b>, uint32 -*</b><i>raster</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFReadRGBAStrip</i> reads a single strip of a -strip-based image into memory, storing the result in the -user supplied RGBA <i>raster</i>. The raster is assumed to -be an array of width times rowsperstrip 32-bit entries, -where width is the width of the image (TIFFTAG_IMAGEWIDTH) -and rowsperstrip is the maximum lines in a strip -(TIFFTAG_ROWSPERSTRIP).</p> -<!-- INDENTATION --> -<p>The <i>row</i> value should be the row of the first row -in the strip (strip * rowsperstrip, zero based).</p> -<!-- INDENTATION --> -<p>Note that the raster is assume to be organized such that -the pixel at location (<i>x</i>,<i>y</i>) is -<i>raster</i>[<i>y</i>*<i>width</i>+<i>x</i>]; with the -raster origin in the <i>lower-left hand corner</i> of the -strip. That is bottom to top organization. When reading a -partial last strip in the file the last line of the image -will begin at the beginning of the buffer.</p> -<!-- INDENTATION --> -<p>Raster pixels are 8-bit packed red, green, blue, alpha -samples. The macros <i>TIFFGetR</i>, <i>TIFFGetG</i>, -<i>TIFFGetB</i>, and <i>TIFFGetA</i> should be used to -access individual samples. Images without Associated Alpha -matting information have a constant Alpha of 1.0 (255).</p> -<!-- INDENTATION --> -<p>See the <i>TIFFRGBAImage</i>(3TIFF) page for more details -on how various image types are converted to RGBA values.</p> -</td> -</table> -<a name="NOTES"></a> -<h2>NOTES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Samples must be either 1, 2, 4, 8, or 16 bits. -Colorimetric samples/pixel must be either 1, 3, or 4 (i.e. -<i>SamplesPerPixel</i> minus <i>ExtraSamples</i>).</p> -<!-- INDENTATION --> -<p>Palette image colormaps that appear to be incorrectly -written as 8-bit values are automatically scaled to -16-bits.</p> -<!-- INDENTATION --> -<p><i>TIFFReadRGBAStrip</i> is just a wrapper around the -more general <i>TIFFRGBAImage</i>(3TIFF) facilities. -It’s main advantage over the similar -<i>TIFFReadRGBAImage()</i> function is that for large images -a single buffer capable of holding the whole image -doesn’t need to be allocated, only enough for one -strip. The <i>TIFFReadRGBATile()</i> function does a similar -operation for tiled images.</p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>1 is returned if the image was successfully read and -converted. Otherwise, 0 is returned if an error was -encountered.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>All error messages are directed to the -<i>TIFFError</i>(3TIFF) routine.</p> -<!-- INDENTATION --> -<p><b>Sorry, can not handle %d-bit pictures</b>. The image -had <i>BitsPerSample</i> other than 1, 2, 4, 8, or 16.</p> -<!-- INDENTATION --> -<p><b>Sorry, can not handle %d-channel images</b>. The image -had <i>SamplesPerPixel</i> other than 1, 3, or 4.</p> -<!-- INDENTATION --> -<p><b>Missing needed "PhotometricInterpretation" -tag</b>. The image did not have a tag that describes how to -display the data.</p> -<!-- INDENTATION --> -<p><b>No "PhotometricInterpretation" tag, assuming -RGB</b>. The image was missing a tag that describes how to -display it, but because it has 3 or 4 samples/pixel, it is -assumed to be <small>RGB.</small></p> -<!-- INDENTATION --> -<p><b>No "PhotometricInterpretation" tag, assuming -min-is-black</b>. The image was missing a tag that describes -how to display it, but because it has 1 sample/pixel, it is -assumed to be a grayscale or bilevel image.</p> -<!-- INDENTATION --> -<p><b>No space for photometric conversion table</b>. There -was insufficient memory for a table used to convert image -samples to 8-bit <small>RGB.</small></p> -<!-- INDENTATION --> -<p><b>Missing required "Colormap" tag</b>. A -Palette image did not have a required <i>Colormap</i> -tag.</p> -<!-- INDENTATION --> -<p><b>No space for tile buffer</b>. There was insufficient -memory to allocate an i/o buffer.</p> -<!-- INDENTATION --> -<p><b>No space for strip buffer</b>. There was insufficient -memory to allocate an i/o buffer.</p> -<!-- INDENTATION --> -<p><b>Can not handle format</b>. The image has a format -(combination of <i>BitsPerSample</i>, -<i>SamplesPerPixel</i>, and -<i>PhotometricInterpretation</i>) that -<i>TIFFReadRGBAImage</i> can not handle.</p> -<!-- INDENTATION --> -<p><b>No space for B&W mapping table</b>. There was -insufficient memory to allocate a table used to map -grayscale data to <small>RGB.</small></p> -<!-- INDENTATION --> -<p><b>No space for Palette mapping table</b>. There was -insufficient memory to allocate a table used to map data to -8-bit <small>RGB.</small></p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>TIFFOpen</b>(3TIFF), <b>TIFFRGBAImage</b>(3TIFF), -<b>TIFFReadRGBAImage</b>(3TIFF), -<b>TIFFReadRGBATile</b>(3TIFF), <b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFReadRGBATile.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFReadRGBATile.3tiff.html deleted file mode 100644 index ed67b83..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFReadRGBATile.3tiff.html +++ /dev/null @@ -1,261 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:16 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFReadRGBATile</title> -</head> -<body> - -<h1 align=center>TIFFReadRGBATile</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#NOTES">NOTES</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFReadRGBATile − read and decode an image tile -into a fixed-format raster</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -</td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="-2%"> - -<p><b>#define TIFFGetR(abgr)</b></p> -</td> -<td width="25%"></td> -<td width="6%"></td> -<td width="61%"> - -<p><b>((abgr) & 0xff)</b></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="-2%"> - -<p><b>#define TIFFGetG(abgr)</b></p> -</td> -<td width="25%"></td> -<td width="6%"></td> -<td width="61%"> - -<p><b>(((abgr) >> 8) & 0xff)</b></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="-2%"> - -<p><b>#define TIFFGetB(abgr)</b></p> -</td> -<td width="25%"></td> -<td width="6%"></td> -<td width="61%"> - -<p><b>(((abgr) >> 16) & 0xff)</b></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="-2%"> - -<p><b>#define TIFFGetA(abgr)</b></p> -</td> -<td width="25%"></td> -<td width="6%"></td> -<td width="61%"> - -<p><b>(((abgr) >> 24) & 0xff)</b></p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>int TIFFReadRGBATile(TIFF *</b><i>tif</i><b>, -uint32</b> <i>x</i><b>, uint32</b> <i>y</i><b>, uint32 -*</b><i>raster</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFReadRGBATile</i> reads a single tile of a -tile-based image into memory, storing the result in the user -supplied RGBA <i>raster</i>. The raster is assumed to be an -array of width times length 32-bit entries, where width is -the width of a tile (TIFFTAG_TILEWIDTH) and length is the -height of a tile (TIFFTAG_TILELENGTH).</p> -<!-- INDENTATION --> -<p>The <i>x</i> and <i>y</i> values are the offsets from the -top left corner to the top left corner of the tile to be -read. They must be an exact multiple of the tile width and -length.</p> -<!-- INDENTATION --> -<p>Note that the raster is assume to be organized such that -the pixel at location (<i>x</i>,<i>y</i>) is -<i>raster</i>[<i>y</i>*<i>width</i>+<i>x</i>]; with the -raster origin in the <i>lower-left hand corner</i> of the -tile. That is bottom to top organization. Edge tiles which -partly fall off the image will be filled out with -appropriate zeroed areas.</p> -<!-- INDENTATION --> -<p>Raster pixels are 8-bit packed red, green, blue, alpha -samples. The macros <i>TIFFGetR</i>, <i>TIFFGetG</i>, -<i>TIFFGetB</i>, and <i>TIFFGetA</i> should be used to -access individual samples. Images without Associated Alpha -matting information have a constant Alpha of 1.0 (255).</p> -<!-- INDENTATION --> -<p>See the <i>TIFFRGBAImage</i>(3TIFF) page for more details -on how various image types are converted to RGBA values.</p> -</td> -</table> -<a name="NOTES"></a> -<h2>NOTES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Samples must be either 1, 2, 4, 8, or 16 bits. -Colorimetric samples/pixel must be either 1, 3, or 4 (i.e. -<i>SamplesPerPixel</i> minus <i>ExtraSamples</i>).</p> -<!-- INDENTATION --> -<p>Palette image colormaps that appear to be incorrectly -written as 8-bit values are automatically scaled to -16-bits.</p> -<!-- INDENTATION --> -<p><i>TIFFReadRGBATile</i> is just a wrapper around the more -general <i>TIFFRGBAImage</i>(3TIFF) facilities. It’s -main advantage over the similar <i>TIFFReadRGBAImage()</i> -function is that for large images a single buffer capable of -holding the whole image doesn’t need to be allocated, -only enough for one tile. The <i>TIFFReadRGBAStrip()</i> -function does a similar operation for stripped images.</p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>1 is returned if the image was successfully read and -converted. Otherwise, 0 is returned if an error was -encountered.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>All error messages are directed to the -<i>TIFFError</i>(3TIFF) routine.</p> -<!-- INDENTATION --> -<p><b>Sorry, can not handle %d-bit pictures</b>. The image -had <i>BitsPerSample</i> other than 1, 2, 4, 8, or 16.</p> -<!-- INDENTATION --> -<p><b>Sorry, can not handle %d-channel images</b>. The image -had <i>SamplesPerPixel</i> other than 1, 3, or 4.</p> -<!-- INDENTATION --> -<p><b>Missing needed "PhotometricInterpretation" -tag</b>. The image did not have a tag that describes how to -display the data.</p> -<!-- INDENTATION --> -<p><b>No "PhotometricInterpretation" tag, assuming -RGB</b>. The image was missing a tag that describes how to -display it, but because it has 3 or 4 samples/pixel, it is -assumed to be <small>RGB.</small></p> -<!-- INDENTATION --> -<p><b>No "PhotometricInterpretation" tag, assuming -min-is-black</b>. The image was missing a tag that describes -how to display it, but because it has 1 sample/pixel, it is -assumed to be a grayscale or bilevel image.</p> -<!-- INDENTATION --> -<p><b>No space for photometric conversion table</b>. There -was insufficient memory for a table used to convert image -samples to 8-bit <small>RGB.</small></p> -<!-- INDENTATION --> -<p><b>Missing required "Colormap" tag</b>. A -Palette image did not have a required <i>Colormap</i> -tag.</p> -<!-- INDENTATION --> -<p><b>No space for tile buffer</b>. There was insufficient -memory to allocate an i/o buffer.</p> -<!-- INDENTATION --> -<p><b>No space for strip buffer</b>. There was insufficient -memory to allocate an i/o buffer.</p> -<!-- INDENTATION --> -<p><b>Can not handle format</b>. The image has a format -(combination of <i>BitsPerSample</i>, -<i>SamplesPerPixel</i>, and -<i>PhotometricInterpretation</i>) that -<i>TIFFReadRGBAImage</i> can not handle.</p> -<!-- INDENTATION --> -<p><b>No space for B&W mapping table</b>. There was -insufficient memory to allocate a table used to map -grayscale data to <small>RGB.</small></p> -<!-- INDENTATION --> -<p><b>No space for Palette mapping table</b>. There was -insufficient memory to allocate a table used to map data to -8-bit <small>RGB.</small></p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>TIFFOpen</b>(3TIFF), <b>TIFFRGBAImage</b>(3TIFF), -<b>TIFFReadRGBAImage</b>(3TIFF), -<b>TIFFReadRGBAStrip</b>(3TIFF), <b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFReadRawStrip.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFReadRawStrip.3tiff.html deleted file mode 100644 index bd14f72..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFReadRawStrip.3tiff.html +++ /dev/null @@ -1,109 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:16 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFReadRawStrip</title> -</head> -<body> - -<h1 align=center>TIFFReadRawStrip</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFReadRawStrip − return the undecoded contents of -a strip of data from an open <small>TIFF</small> file</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>tsize_t TIFFReadRawStrip(TIFF *</b><i>tif</i><b>, -tstrip_t</b> <i>strip</i><b>, tdata_t</b> <i>buf</i><b>, -tsize_t</b> <i>size</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Read the contents of the specified strip into the (user -supplied) data buffer. Note that the value of <i>strip</i> -is a ‘‘raw strip number.’’ That is, -the caller must take into account whether or not the data is -organized in separate planes (<i>PlanarConfiguration</i>=2). -To read a full strip of data the data buffer should -typically be at least as large as the number returned by -<i>TIFFStripSize</i>.</p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The actual number of bytes of data that were placed in -<i>buf</i> is returned; <i>TIFFReadEncodedStrip</i> returns -−1 if an error was encountered.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>All error messages are directed to the -<b>TIFFError</b>(3TIFF) routine.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>TIFFOpen</b>(3TIFF), -<b>TIFFReadEncodedStrip</b>(3TIFF), -<b>TIFFReadScanline</b>(3TIFF), <b>TIFFStripSize</b>(3TIFF), -<b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFReadRawTile.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFReadRawTile.3tiff.html deleted file mode 100644 index bae2b46..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFReadRawTile.3tiff.html +++ /dev/null @@ -1,111 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:16 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFReadRawTile</title> -</head> -<body> - -<h1 align=center>TIFFReadRawTile</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFReadRawTile − return an undecoded tile of data -from an open <small>TIFF</small> file</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>tsize_t TIFFReadRawTile(TIFF *</b><i>tif</i><b>, -ttile_t</b> <i>tile</i><b>, tdata_t</b> <i>buf</i><b>, -tsize_t</b> <i>size</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Read the contents of the specified tile into the (user -supplied) data buffer. Note that the value of <i>tile</i> is -a ‘‘raw tile number.’’ That is, the -caller must take into account whether or not the data is -organized in separate planes (<i>PlanarConfiguration</i>=2). -<i>TIFFComputeTile</i> automatically does this when -converting an (x,y,z,sample) coordinate quadruple to a tile -number. To read a full tile of data the data buffer should -typically be at least as large as the value returned by -<i>TIFFTileSize</i>.</p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The actual number of bytes of data that were placed in -<i>buf</i> is returned; <i>TIFFReadEncodedTile</i> returns -−1 if an error was encountered.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>All error messages are directed to the -<b>TIFFError</b>(3TIFF) routine.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>TIFFOpen</b>(3TIFF), -<b>TIFFReadEncodedTile</b>(3TIFF), -<b>TIFFReadTile</b>(3TIFF), <b>TIFFTileSize</b>(3TIFF), -<b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFReadScanline.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFReadScanline.3tiff.html deleted file mode 100644 index 423645c..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFReadScanline.3tiff.html +++ /dev/null @@ -1,157 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:16 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFReadScanline</title> -</head> -<body> - -<h1 align=center>TIFFReadScanline</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#NOTES">NOTES</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#BUGS">BUGS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFReadScanline − read and decode a scanline of -data from an open <small>TIFF</small> file</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>int TIFFReadScanline(TIFF *</b><i>tif</i><b>, -tdata_t</b> <i>buf</i><b>, uint32</b> <i>row</i><b>, -tsample_t</b> <i>sample</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Read the data for the specified row into the (user -supplied) data buffer <i>buf</i>. The data are returned -decompressed and, in the native byte- and bit-ordering, but -are otherwise packed (see further below). The buffer must be -large enough to hold an entire scanline of data. -Applications should call the routine <i>TIFFScanlineSize</i> -to find out the size (in bytes) of a scanline buffer. The -<i>row</i> parameter is always used by -<i>TIFFReadScanline</i>; the <i>sample</i> parameter is used -only if data are organized in separate planes -(<i>PlanarConfiguration</i>=2).</p> -</td> -</table> -<a name="NOTES"></a> -<h2>NOTES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The library attempts to hide bit- and byte-ordering -differences between the image and the native machine by -converting data to the native machine order. Bit reversal is -done if the <i>FillOrder</i> tag is opposite to the native -machine bit order. 16- and 32-bit samples are automatically -byte-swapped if the file was written with a byte order -opposite to the native machine byte order,</p> -<!-- INDENTATION --> -<p>In C++ the <i>sample</i> parameter defaults to 0.</p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFReadScanline</i> returns −1 if it detects an -error; otherwise 1 is returned.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>All error messages are directed to the -<i>TIFFError</i>(3TIFF) routine.</p> -<!-- INDENTATION --> -<p><b>Compression algorithm does not support random -access</b>. Data was requested in a non-sequential order -from a file that uses a compression algorithm and that has -<i>RowsPerStrip</i> greater than one. That is, data in the -image is stored in a compressed form, and with multiple rows -packed into a strip. In this case, the library does not -support random access to the data. The data should either be -accessed sequentially, or the file should be converted so -that each strip is made up of one row of data.</p> -</td> -</table> -<a name="BUGS"></a> -<h2>BUGS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Reading subsampled YCbCR data does not work correctly -because, for <i>PlanarConfiguration</i>=2 the size of a -scanline is not calculated on a per-sample basis, and for -<i>PlanarConfiguration</i>=1 the library does not unpack the -block-interleaved samples; use the strip- and tile-based -interfaces to read these formats.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>TIFFOpen</b>(3TIFF), -<b>TIFFReadEncodedStrip</b>(3TIFF), -<b>TIFFReadRawStrip</b>(3TIFF), <b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFReadTile.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFReadTile.3tiff.html deleted file mode 100644 index ff726b4..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFReadTile.3tiff.html +++ /dev/null @@ -1,133 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:16 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFReadTile</title> -</head> -<body> - -<h1 align=center>TIFFReadTile</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#NOTES">NOTES</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFReadTile − read and decode a tile of data from -an open <small>TIFF</small> file</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>tsize_t TIFFReadTile(TIFF *</b><i>tif</i><b>, -tdata_t</b> <i>buf</i><b>, uint32</b> <i>x</i><b>, -uint32</b> <i>y</i><b>, uint32</b> <i>z</i><b>, -tsample_t</b> <i>sample</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Return the data for the tile <i>containing</i> the -specified coordinates. The data placed in <i>buf</i> are -returned decompressed and, typically, in the native byte- -and bit-ordering, but are otherwise packed (see further -below). The buffer must be large enough to hold an entire -tile of data. Applications should call the routine -<i>TIFFTileSize</i> to find out the size (in bytes) of a -tile buffer. The <i>x</i> and <i>y</i> parameters are always -used by <i>TIFFReadTile</i>. The <i>z</i> parameter is used -if the image is deeper than 1 slice -(<i>ImageDepth</i>>1). The <i>sample</i> parameter is -used only if data are organized in separate planes -(<i>PlanarConfiguration</i>=2).</p> -</td> -</table> -<a name="NOTES"></a> -<h2>NOTES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The library attempts to hide bit- and byte-ordering -differences between the image and the native machine by -converting data to the native machine order. Bit reversal is -done if the <i>FillOrder</i> tag is opposite to the native -machine bit order. 16- and 32-bit samples are automatically -byte-swapped if the file was written with a byte order -opposite to the native machine byte order,</p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFReadTile</i> returns −1 if it detects an -error; otherwise the number of bytes in the decoded tile is -returned.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>All error messages are directed to the -<b>TIFFError</b>(3TIFF) routine.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>TIFFCheckTile</b>(3TIFF), -<b>TIFFComputeTile</b>(3TIFF), <b>TIFFOpen</b>(3TIFF), -<b>TIFFReadEncodedTile</b>(3TIFF), -<b>TIFFReadRawTile</b>(3TIFF), <b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFSetDirectory.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFSetDirectory.3tiff.html deleted file mode 100644 index a0e5cfc..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFSetDirectory.3tiff.html +++ /dev/null @@ -1,122 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:17 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFSetDirectory</title> -</head> -<body> - -<h1 align=center>TIFFSetDirectory</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFSetDirectory, TIFFSetSubDirectory − set the -current directory for an open <small>TIFF</small> file</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>int TIFFSetDirectory(TIFF *</b><i>tif</i><b>, -tdir_t</b> <i>dirnum</i><b>)<br> -int TIFFSetSubDirectory(TIFF *</b><i>tif</i><b>, uint32</b> -<i>diroff</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFSetDirectory</i> changes the current directory and -reads its contents with <i>TIFFReadDirectory</i>. The -parameter <i>dirnum</i> specifies the subfile/directory as -an integer number, with the first directory numbered -zero.</p> -<!-- INDENTATION --> -<p><i>TIFFSetSubDirectory</i> acts like -<i>TIFFSetDirectory</i>, except the directory is specified -as a file offset instead of an index; this is required for -accessing subdirectories linked through a <i>SubIFD</i> -tag.</p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>On successful return 1 is returned. Otherwise, 0 is -returned if <i>dirnum</i> or <i>diroff</i> specifies a -non-existent directory, or if an error was encountered while -reading the directory’s contents.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>All error messages are directed to the -<i>TIFFError</i>(3TIFF) routine.</p> -<!-- INDENTATION --> -<p><b>%s: Error fetching directory count</b>. An error was -encountered while reading the ‘‘directory -count’’ field.</p> -<!-- INDENTATION --> -<p><b>%s: Error fetching directory link</b>. An error was -encountered while reading the ‘‘link -value’’ that points to the next directory in a -file.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFCurrentDirectory</i>(3TIFF), -<i>TIFFOpen</i>(3TIFF), <i>TIFFReadDirectory</i>(3TIFF), -<i>TIFFWriteDirectory</i>(3TIFF), <i>libtiff</i>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFSetField.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFSetField.3tiff.html deleted file mode 100644 index 2e70225..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFSetField.3tiff.html +++ /dev/null @@ -1,1362 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:17 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFSetField</title> -</head> -<body> - -<h1 align=center>TIFFSetField</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFSetField, TIFFVSetField − set the value(s) of a -tag in a <small>TIFF</small> file open for writing</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>int TIFFSetField(TIFF *</b><i>tif</i><b>, ttag_t</b> -<i>tag</i><b>,</b> <i>...</i><b>)</b></p> -<!-- INDENTATION --> -<p><b>#include <stdarg.h></b></p> -<!-- INDENTATION --> -<p><b>int TIFFVSetField(TIFF *</b><i>tif</i><b>, ttag_t</b> -<i>tag</i><b>, va_list</b> <i>ap</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFSetField</i> sets the value of a field or -pseudo-tag in the current directory associated with the open -<small>TIFF</small> file <i>tif</i>. (A <i>pseudo-tag</i> is -a parameter that is used to control the operation of the -<small>TIFF</small> library but whose value is not read or -written to the underlying file.) To set the value of a field -the file must have been previously opened for writing with -<i>TIFFOpen</i>(3TIFF); pseudo-tags can be set whether the -file was opened for reading or writing. The field is -identified by <i>tag</i>, one of the values defined in the -include file <b>tiff.h</b> (see also the table below). The -actual value is specified using a variable argument list, as -prescribed by the <i>stdarg</i>(3) interface (or, on some -machines, the <i>varargs</i>(3) interface.)</p> -<!-- INDENTATION --> -<p><i>TIFFVSetField</i> is functionally equivalent to -<i>TIFFSetField</i> except that it takes a pointer to a -variable argument list. <i>TIFFVSetField</i> is useful for -writing routines that are layered on top of the -functionality provided by <i>TIFFSetField</i>.</p> -<!-- INDENTATION --> -<p>The tags understood by <i>libtiff</i>, the number of -parameter values, and the expected types for the parameter -values are shown below. The data types are: <i>char*</i> is -null-terminated string and corresponds to the -<small>ASCII</small> data type; <i>uint16</i> is an unsigned -16-bit value; <i>uint32</i> is an unsigned 32-bit value; -<i>uint16*</i> is an array of unsigned 16-bit values. -<i>void*</i> is an array of data values of unspecified -type.</p> -<!-- INDENTATION --> -<p>Consult the <small>TIFF</small> specification for -information on the meaning of each tag.</p></td> -</table> -<!-- TABS --> - -<p><i>Tag Name Count Types Notes</i></p> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_ARTIST</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>char*</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_BADFAXLINES</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint32</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_BITSPERSAMPLE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint16</p> -</td> -<td width="16%"> - -<p>†</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_CLEANFAXDATA</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint16</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_COLORMAP</p> -</td> -<td width="8%"> - -<p>3</p> -</td> -<td width="24%"> - -<p>uint16*</p> -</td> -<td width="16%"> - -<p>1<<BitsPerSample arrays</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_COMPRESSION</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint16</p> -</td> -<td width="16%"> - -<p>†</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_CONSECUTIVEBADFAXLINES</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint32</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_COPYRIGHT</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>char*</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_DATETIME</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>char*</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_DOCUMENTNAME</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>char*</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_DOTRANGE</p> -</td> -<td width="8%"> - -<p>2</p> -</td> -<td width="24%"> - -<p>uint16</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_EXTRASAMPLES</p> -</td> -<td width="8%"> - -<p>2</p> -</td> -<td width="24%"> - -<p>uint16,uint16*</p> -</td> -<td width="16%"> - -<p>† count & types array</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_FAXFILLFUNC</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>TIFFFaxFillFunc</p> -</td> -<td width="16%"> - -<p>G3/G4 compression pseudo-tag</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_FAXMODE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>int</p> -</td> -<td width="16%"> - -<p>† G3/G4 compression pseudo-tag</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_FILLORDER</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint16</p> -</td> -<td width="16%"> - -<p>†</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_GROUP3OPTIONS</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint32</p> -</td> -<td width="16%"> - -<p>†</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_GROUP4OPTIONS</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint32</p> -</td> -<td width="16%"> - -<p>†</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_HALFTONEHINTS</p> -</td> -<td width="8%"> - -<p>2</p> -</td> -<td width="24%"> - -<p>uint16</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_HOSTCOMPUTER</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>char*</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_ICCPROFILE</p> -</td> -<td width="8%"> - -<p>2</p> -</td> -<td width="24%"> - -<p>uint32,void*</p> -</td> -<td width="16%"> - -<p>count, profile data</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_IMAGEDEPTH</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint32</p> -</td> -<td width="16%"> - -<p>†</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_IMAGEDESCRIPTION</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>char*</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_IMAGELENGTH</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint32</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_IMAGEWIDTH</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint32</p> -</td> -<td width="16%"> - -<p>†</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_INKNAMES</p> -</td> -<td width="8%"> - -<p>2</p> -</td> -<td width="24%"> - -<p>uint16, char*</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_INKSET</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint16</p> -</td> -<td width="16%"> - -<p>†</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_JPEGCOLORMODE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>int</p> -</td> -<td width="16%"> - -<p>† JPEG pseudo-tag</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_JPEGQUALITY</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>int</p> -</td> -<td width="16%"> - -<p>JPEG pseudo-tag</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_JPEGTABLES</p> -</td> -<td width="8%"> - -<p>2</p> -</td> -<td width="24%"> - -<p>uint32*,void*</p> -</td> -<td width="16%"> - -<p>† count & tables</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_JPEGTABLESMODE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>int</p> -</td> -<td width="16%"> - -<p>† JPEG pseudo-tag</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_MAKE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>char*</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_MATTEING</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint16</p> -</td> -<td width="16%"> - -<p>†</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_MAXSAMPLEVALUE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint16</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_MINSAMPLEVALUE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint16</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_MODEL</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>char*</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_ORIENTATION</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint16</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_PAGENAME</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>char*</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_PAGENUMBER</p> -</td> -<td width="8%"> - -<p>2</p> -</td> -<td width="24%"> - -<p>uint16</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_PHOTOMETRIC</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint16</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_PHOTOSHOP</p> -</td> -<td width="8%"> - -<p>?</p> -</td> -<td width="24%"> - -<p>uint32,void*</p> -</td> -<td width="16%"> - -<p>count, data</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_PLANARCONFIG</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint16</p> -</td> -<td width="16%"> - -<p>†</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_PREDICTOR</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint16</p> -</td> -<td width="16%"> - -<p>†</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_PRIMARYCHROMATICITIES</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>float*</p> -</td> -<td width="16%"> - -<p>6-entry array</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_REFERENCEBLACKWHITE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>float*</p> -</td> -<td width="16%"> - -<p>† 2*SamplesPerPixel array</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_RESOLUTIONUNIT</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint16</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_RICHTIFFIPTC</p> -</td> -<td width="8%"> - -<p>2</p> -</td> -<td width="24%"> - -<p>uint32,void*</p> -</td> -<td width="16%"> - -<p>count, data</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_ROWSPERSTRIP</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint32</p> -</td> -<td width="16%"> - -<p>† must be > 0</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_SAMPLEFORMAT</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint16</p> -</td> -<td width="16%"> - -<p>†</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_SAMPLESPERPIXEL</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint16</p> -</td> -<td width="16%"> - -<p>† value must be <= 4</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_SMAXSAMPLEVALUE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>double</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_SMINSAMPLEVALUE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>double</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_SOFTWARE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>char*</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_STONITS</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>double</p> -</td> -<td width="16%"> - -<p>†</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_SUBFILETYPE</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint32</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_SUBIFD</p> -</td> -<td width="8%"> - -<p>2</p> -</td> -<td width="24%"> - -<p>uint16,uint32*</p> -</td> -<td width="16%"> - -<p>count & offsets array</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_TARGETPRINTER</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>char*</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_THRESHHOLDING</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint16</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_TILEDEPTH</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint32</p> -</td> -<td width="16%"> - -<p>†</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_TILELENGTH</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint32</p> -</td> -<td width="16%"> - -<p>† must be a multiple of 8</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_TILEWIDTH</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint32</p> -</td> -<td width="16%"> - -<p>† must be a multiple of 8</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_TRANSFERFUNCTION</p> -</td> -<td width="8%"> - -<p>1 or 3‡ uint16*</p> -</td> -<td width="24%"></td> -<td width="16%"> - -<p>1<<BitsPerSample entry arrays</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_WHITEPOINT</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>float*</p> -</td> -<td width="16%"> - -<p>2-entry array</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_XMLPACKET</p> -</td> -<td width="8%"> - -<p>2</p> -</td> -<td width="24%"> - -<p>uint32,void*</p> -</td> -<td width="16%"> - -<p>count, data</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_XPOSITION</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>float</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_XRESOLUTION</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>float</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_YCBCRCOEFFICIENTS</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>float*</p> -</td> -<td width="16%"> - -<p>† 3-entry array</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_YCBCRPOSITIONING</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>uint16</p> -</td> -<td width="16%"> - -<p>†</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_YCBCRSAMPLING</p> -</td> -<td width="8%"> - -<p>2</p> -</td> -<td width="24%"> - -<p>uint16</p> -</td> -<td width="16%"> - -<p>†</p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_YPOSITION</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>float</p> -</td> -<td width="16%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="41%"> - -<p>TIFFTAG_YRESOLUTION</p> -</td> -<td width="8%"> - -<p>1</p> -</td> -<td width="24%"> - -<p>float</p> -</td> -<td width="16%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>† Tag may not have its values changed once data is -written.<br> -‡ If <i>SamplesPerPixel</i> is one, then a single -array is passed; otherwise three arrays should be -passed.<br> -* The contents of this field are quite complex. See <b>The -ICC Profile Format Specification</b>, Annex B.3 -"Embedding ICC Profiles in TIFF Files" (available -at http://www.color.org) for an explanation.</p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>1 is returned if the operation was successful. Otherwise, -0 is returned if an error was detected.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>All error messages are directed to the -<b>TIFFError</b>(3TIFF) routine.</p> -<!-- INDENTATION --> -<p><b>%s: Cannot modify tag "%s" while -writing</b>. Data has already been written to the file, so -the specified tag’s value can not be changed. This -restriction is applied to all tags that affect the format of -written data.</p> -<!-- INDENTATION --> -<p><b>%d: Bad value for "%s"</b>. An invalid value -was supplied for the named tag.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>TIFFOpen</b>(3TIFF), <b>TIFFGetField</b>(3TIFF), -<b>TIFFSetDirectory</b>(3TIFF), -<b>TIFFWriteDirectory</b>(3TIFF), -<b>TIFFReadDirectory</b>(3TIFF), <b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFWarning.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFWarning.3tiff.html deleted file mode 100644 index df17073..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFWarning.3tiff.html +++ /dev/null @@ -1,108 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:17 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFWarning</title> -</head> -<body> - -<h1 align=center>TIFFWarning</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFWarning, TIFFSetWarningHandler − library -warning interface</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>void TIFFWarning(const char *</b><i>module</i><b>, -const char *</b><i>fmt</i><b>,</b> <i>...</i><b>)</b></p> -<!-- INDENTATION --> -<p><b>#include <stdargh.h></b></p> -<!-- INDENTATION --> -<p><b>typedef void (*TIFFWarningHandler)(const char -*</b><i>module</i><b>, const char *</b><i>fmt</i><b>, -va_list</b> <i>ap</i><b>);</b></p> -<!-- INDENTATION --> -<p><b>TIFFWarningHandler -TIFFSetWarningHandler(TIFFWarningHandler</b> -<i>handler</i><b>);</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFWarning</i> invokes the library-wide warning -handler function to (normally) write a warning message to -the <b>stderr</b>. The <i>fmt</i> parameter is a -<i>printf</i>(3S) format string, and any number arguments -can be supplied. The <i>module</i> parameter is interpreted -as a string that, if non-zero, should be printed before the -message; it typically is used to identify the software -module in which a warning is detected.</p> -<!-- INDENTATION --> -<p>Applications that desire to capture control in the event -of a warning should use <i>TIFFSetWarningHandler</i> to -override the default warning handler. A <small>NULL</small> -(0) warning handler function may be installed to suppress -error messages.</p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFSetWarningHandler</i> returns a reference to the -previous error handling function.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>TIFFError</b>(3TIFF), <b>libtiff</b>(3TIFF), -<b>printf</b>(3)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFWriteDirectory.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFWriteDirectory.3tiff.html deleted file mode 100644 index 07a443e..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFWriteDirectory.3tiff.html +++ /dev/null @@ -1,176 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:17 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFWriteDirectory</title> -</head> -<body> - -<h1 align=center>TIFFWriteDirectory</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFWriteDirectory, TIFFRewriteDirectory, -TIFFCheckpointDirectory − write the current directory -in an open <small>TIFF</small> file</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>int TIFFWriteDirectory(TIFF *</b><i>tif</i><b>)<br> -int TIFFRewriteDirectory(TIFF *</b><i>tif</i><b>)<br> -int TIFFCheckpointDirectory(TIFF *</b><i>tif</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFWriteDirectory</i> will write the contents of the -current directory to the file and setup to create a new -subfile in the same file. Applications only need to call -<i>TIFFWriteDirectory</i> when writing multiple subfiles to -a single <small>TIFF</small> file. <i>TIFFWriteDirectory</i> -is automatically called by <i>TIFFClose</i> and -<i>TIFFFlush</i> to write a modified directory if the file -is open for writing.</p> -<!-- INDENTATION --> -<p>The <i>TIFFRewriteDirectory</i> function operates -similarly to <i>TIFFWriteDirectory,</i> but can be called -with directories previously read or written that already -have an established location in the file. It will rewrite -the directory, but instead of place it at it’s old -location (as <i>TIFFWriteDirectory</i> would) it will place -them at the end of the file, correcting the pointer from the -preceeding directory or file header to point to it’s -new location. This is particularly important in cases where -the size of the directory and pointed to data has grown, so -it won’t fit in the space available at the old -location.</p> -<!-- INDENTATION --> -<p>The <i>TIFFCheckpointDirectory</i> writes the current -state of the tiff directory into the file to make what is -currently in the file readable. Unlike -<i>TIFFWriteDirectory, TIFFCheckpointDirectory</i> does not -free up the directory data structures in memory, so they can -be updated (as strips/tiles are written) and written again. -Reading such a partial file you will at worst get a tiff -read error for the first strip/tile encountered that is -incomplete, but you will at least get all the valid data in -the file before that. When the file is complete, just use -<i>TIFFWriteDirectory</i> as usual to finish it off -cleanly.</p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>1 is returned when the contents are successfully written -to the file. Otherwise, 0 is returned if an error was -encountered when writing the directory contents.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>All error messages are directed to the -<i>TIFFError</i>(3TIFF) routine.</p> -<!-- INDENTATION --> -<p><b>Error post-encoding before directory write</b>. Before -writing the contents of the current directory, any pending -data are flushed. This message indicates that an error -occurred while doing this.</p> -<!-- INDENTATION --> -<p><b>Error flushing data before directory write</b>. Before -writing the contents of the current directory, any pending -data are flushed. This message indicates that an error -occurred while doing this.</p> -<!-- INDENTATION --> -<p><b>Cannot write directory, out of space</b>. There was -not enough space to allocate a temporary area for the -directory that was to be written.</p> -<!-- INDENTATION --> -<p><b>Error writing directory count</b>. A write error -occurred when writing the count of fields in the -directory.</p> -<!-- INDENTATION --> -<p><b>Error writing directory contents</b>. A write error -occurred when writing the directory fields.</p> -<!-- INDENTATION --> -<p><b>Error writing directory link</b>. A write error -occurred when writing the link to the next directory.</p> -<!-- INDENTATION --> -<p><b>Error writing data for field "%s"</b>. A -write error occurred when writing indirect data for the -specified field.</p> -<!-- INDENTATION --> -<p><b>Error writing TIFF header</b>. A write error occurred -when re-writing header at the front of the file.</p> -<!-- INDENTATION --> -<p><b>Error fetching directory count</b>. A read error -occurred when fetching the directory count field for a -previous directory. This can occur when setting up a link to -the directory that is being written.</p> -<!-- INDENTATION --> -<p><b>Error fetching directory link</b>. A read error -occurred when fetching the directory link field for a -previous directory. This can occur when setting up a link to -the directory that is being written.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>TIFFOpen</b>(3TIFF), <b>TIFFError</b>(3TIFF), -<b>TIFFReadDirectory</b>(3TIFF), -<b>TIFFSetDirectory</b>(3TIFF), <b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFWriteEncodedStrip.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFWriteEncodedStrip.3tiff.html deleted file mode 100644 index 5a45f59..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFWriteEncodedStrip.3tiff.html +++ /dev/null @@ -1,153 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:17 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFWriteEncodedStrip</title> -</head> -<body> - -<h1 align=center>TIFFWriteEncodedStrip</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#NOTES">NOTES</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>TIFFWritedEncodedStrip − compress and write a -strip of data to an open</big> TIFF <big>file</big></p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big><b>#include <tiffio.h></b></big></p> -<!-- INDENTATION --> -<p><big><b>tsize_t TIFFWriteEncodedStrip(TIFF -*</b><i>tif</i><b>, tstrip_t</b> <i>strip</i><b>, -tdata_t</b> <i>buf</i><b>, tsize_t</b> -<i>size</i><b>)</b></big></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>Compress <i>size</i> bytes of raw data from -<i>buf</i> and write the result to the specified strip; -replacing any previously written data. Note that the value -of <i>strip</i> is a ‘‘raw strip -number.’’ That is, the caller must take into -account whether or not the data are organized in separate -planes (<i>PlanarConfiguration</i>=2).</big></p> -</td> -</table> -<a name="NOTES"></a> -<h2>NOTES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>The library writes encoded data using the native -machine byte order. Correctly implemented</big> TIFF -<big>readers are expected to do any necessary byte-swapping -to correctly process image data with BitsPerSample greater -than 8.</big></p> -<!-- INDENTATION --> -<p><big>The strip number must be valid according to the -current settings of the <i>ImageLength</i> and -<i>RowsPerStrip</i> tags. An image may be dynamically grown -by increasing the value of <i>ImageLength</i> prior to each -call to <i>TIFFWriteEncodedStrip</i>.</big></p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>−1 is returned if an error was encountered. -Otherwise, the value of <i>size</i> is returned.</big></p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>All error messages are directed to the -<i>TIFFError</i>(3TIFF) routine.</big></p> -<!-- INDENTATION --> -<p><big><b>%s: File not open for writing</b>. The file was -opened for reading, not writing.</big></p> -<!-- INDENTATION --> -<p><big><b>Can not write scanlines to a tiled image</b>. The -image is assumed to be organized in tiles because the -<i>TileWidth</i> and <i>TileLength</i> tags have been set -with <i>TIFFSetField</i>(3TIFF).</big></p> -<!-- INDENTATION --> -<p><big><b>%s: Must set "ImageWidth" before -writing data</b>. The image’s width has not be set -before the first write. See <i>TIFFSetField</i>(3TIFF) for -information on how to do this.</big></p> -<!-- INDENTATION --> -<p><big><b>%s: Must set "PlanarConfiguration" -before writing data</b>. The organization of data has not be -defined before the first write. See -<i>TIFFSetField</i>(3TIFF) for information on how to do -this.</big></p> -<!-- INDENTATION --> -<p><big><b>%s: No space for strip arrays"</b>. There -was not enough space for the arrays that hold strip offsets -and byte counts.</big></p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big><b>TIFFOpen</b>(3TIFF), -<b>TIFFWriteScanline</b>(3TIFF), -<b>TIFFWriteRawStrip</b>(3TIFF), -<b>libtiff</b>(3TIFF)</big></p> -<!-- INDENTATION --> -<p><big>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></big></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFWriteEncodedTile.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFWriteEncodedTile.3tiff.html deleted file mode 100644 index 0e6e1ba..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFWriteEncodedTile.3tiff.html +++ /dev/null @@ -1,147 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:17 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFWriteEncodedTile</title> -</head> -<body> - -<h1 align=center>TIFFWriteEncodedTile</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#NOTES">NOTES</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>TIFFWritedEncodedTile − compress and write a -tile of data to an open</big> TIFF <big>file</big></p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big><b>#include <tiffio.h></b></big></p> -<!-- INDENTATION --> -<p><big><b>tsize_t TIFFWriteEncodedTile(TIFF -*</b><i>tif</i><b>, ttile_t</b> <i>tile</i><b>, tdata_t</b> -<i>buf</i><b>, tsize_t</b> <i>size</i><b>)</b></big></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>Compress <i>size</i> bytes of raw data from -<i>buf</i> and <b>append</b> the result to the end of the -specified tile. Note that the value of <i>tile</i> is a -‘‘raw tile number.’’ That is, the -caller must take into account whether or not the data are -organized in separate places (<i>PlanarConfiguration</i>=2). -<i>TIFFComputeTile</i> automatically does this when -converting an (x,y,z,sample) coordinate quadruple to a tile -number.</big></p> -</td> -</table> -<a name="NOTES"></a> -<h2>NOTES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>The library writes encoded data using the native -machine byte order. Correctly implemented</big> TIFF -<big>readers are expected to do any necessary byte-swapping -to correctly process image data with BitsPerSample greater -than 8.</big></p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>−1 is returned if an error was encountered. -Otherwise, the value of <i>size</i> is returned.</big></p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>All error messages are directed to the -<b>TIFFError</b>(3TIFF) routine.</big></p> -<!-- INDENTATION --> -<p><big><b>%s: File not open for writing</b>. The file was -opened for reading, not writing.</big></p> -<!-- INDENTATION --> -<p><big><b>Can not write tiles to a stripped image</b>. The -image is assumed to be organized in strips because neither -of the <i>TileWidth</i> or <i>TileLength</i> tags have been -set with <b>TIFFSetField</b>(3TIFF).</big></p> -<!-- INDENTATION --> -<p><big><b>%s: Must set "ImageWidth" before -writing data</b>. The image’s width has not be set -before the first write. See <b>TIFFSetField</b>(3TIFF) for -information on how to do this.</big></p> -<!-- INDENTATION --> -<p><big><b>%s: Must set "PlanarConfiguration" -before writing data</b>. The organization of data has not be -defined before the first write. See -<b>TIFFSetField</b>(3TIFF) for information on how to do -this.</big></p> -<!-- INDENTATION --> -<p><big><b>%s: No space for tile arrays"</b>. There was -not enough space for the arrays that hold tile offsets and -byte counts.</big></p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big><b>TIFFOpen</b>(3TIFF), <b>TIFFWriteTile</b>(3TIFF), -<b>TIFFWriteRawTile</b>(3TIFF), -<b>libtiff</b>(3TIFF)</big></p> -<!-- INDENTATION --> -<p><big>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></big></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFWriteRawStrip.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFWriteRawStrip.3tiff.html deleted file mode 100644 index 95b4857..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFWriteRawStrip.3tiff.html +++ /dev/null @@ -1,144 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:17 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFWriteRawstrip</title> -</head> -<body> - -<h1 align=center>TIFFWriteRawstrip</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#NOTES">NOTES</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFWriteRawStrip − write a strip of raw data to an -open <small>TIFF</small> file</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>tsize_t TIFFWriteRawStrip(TIFF *</b><i>tif</i><b>, -tstrip_t</b> <i>strip</i><b>, tdata_t</b> <i>buf</i><b>, -tsize_t</b> <i>size</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Append <i>size</i> bytes of raw data to the specified -strip.</p> -</td> -</table> -<a name="NOTES"></a> -<h2>NOTES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The strip number must be valid according to the current -settings of the <i>ImageLength</i> and <i>RowsPerStrip</i> -tags. An image may be dynamically grown by increasing the -value of <i>ImageLength</i> prior to each call to -<i>TIFFWriteRawStrip</i>.</p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>−1 is returned if an error occurred. Otherwise, the -value of <i>size</i> is returned.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>All error messages are directed to the -<b>TIFFError</b>(3TIFF) routine.</p> -<!-- INDENTATION --> -<p><b>%s: File not open for writing</b>. The file was opened -for reading, not writing.</p> -<!-- INDENTATION --> -<p><b>Can not write scanlines to a tiled image</b>. The -image is assumed to be organized in tiles because the -<i>TileWidth</i> and <i>TileLength</i> tags have been set -with <b>TIFFSetField</b>(3TIFF).</p> -<!-- INDENTATION --> -<p><b>%s: Must set "ImageWidth" before writing -data</b>. The image’s width has not be set before the -first write. See <b>TIFFSetField</b>(3TIFF) for information -on how to do this.</p> -<!-- INDENTATION --> -<p><b>%s: Must set "PlanarConfiguration" before -writing data</b>. The organization of data has not be -defined before the first write. See -<b>TIFFSetField</b>(3TIFF) for information on how to do -this.</p> -<!-- INDENTATION --> -<p><b>%s: No space for strip arrays"</b>. There was not -enough space for the arrays that hold strip offsets and byte -counts.</p> -<!-- INDENTATION --> -<p><b>%s: Strip %d out of range, max %d</b>. The specified -strip is not a valid strip according to the currently -specified image dimensions.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>TIFFOpen</b>(3TIFF), -<b>TIFFWriteEncodedStrip</b>(3TIFF), -<b>TIFFWriteScanline</b>(3TIFF), <b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFWriteRawTile.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFWriteRawTile.3tiff.html deleted file mode 100644 index 3d18ed1..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFWriteRawTile.3tiff.html +++ /dev/null @@ -1,128 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:18 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFWriteRawtile</title> -</head> -<body> - -<h1 align=center>TIFFWriteRawtile</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFWriteRawTile − write a tile of raw data to an -open <small>TIFF</small> file</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>tsize_t TIFFWriteRawTile(TIFF *</b><i>tif</i><b>, -ttile_t</b> <i>tile</i><b>, tdata_t</b> <i>buf</i><b>, -tsize_t</b> <i>size</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Append <i>size</i> bytes of raw data to the specified -tile.</p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>−1 is returned if an error occurred. Otherwise, the -value of <i>size</i> is returned.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>All error messages are directed to the -<b>TIFFError</b>(3TIFF) routine.</p> -<!-- INDENTATION --> -<p><b>%s: File not open for writing</b>. The file was opened -for reading, not writing.</p> -<!-- INDENTATION --> -<p><b>Can not write tiles to a stripped image</b>. The image -is assumed to be organized in strips because neither of the -<i>TileWidth</i> or <i>TileLength</i> tags have been set -with <b>TIFFSetField</b>(3TIFF).</p> -<!-- INDENTATION --> -<p><b>%s: Must set "ImageWidth" before writing -data</b>. The image’s width has not be set before the -first write. See <b>TIFFSetField</b>(3TIFF) for information -on how to do this.</p> -<!-- INDENTATION --> -<p><b>%s: Must set "PlanarConfiguration" before -writing data</b>. The organization of data has not be -defined before the first write. See -<b>TIFFSetField</b>(3TIFF) for information on how to do -this.</p> -<!-- INDENTATION --> -<p><b>%s: No space for tile arrays"</b>. There was not -enough space for the arrays that hold tile offsets and byte -counts.</p> -<!-- INDENTATION --> -<p><b>%s: Specified tile %d out of range, max %d</b>. The -specified tile is not valid according to the currently -specified image dimensions.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>TIFFOpen</b>(3TIFF), -<b>TIFFWriteEncodedTile</b>(3TIFF), -<b>TIFFWriteScanline</b>(3TIFF), <b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFWriteScanline.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFWriteScanline.3tiff.html deleted file mode 100644 index bb9323d..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFWriteScanline.3tiff.html +++ /dev/null @@ -1,206 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:18 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFWriteScanline</title> -</head> -<body> - -<h1 align=center>TIFFWriteScanline</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#NOTES">NOTES</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#BUGS">BUGS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFWriteScanline − write a scanline to an open -<small>TIFF</small> file</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>int TIFFWriteScanline(TIFF *</b><i>tif</i><b>, -tdata_t</b> <i>buf</i><b>, uint32</b> <i>row</i><b>, -tsample_t</b> <i>sample</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Write data to a file at the specified row. The -<i>sample</i> parameter is used only if data are organized -in separate planes (<i>PlanarConfiguration</i>=2). The data -are assumed to be uncompressed and in the native bit- and -byte-order of the host machine. The data written to the file -is compressed according to the compression scheme of the -current <small>TIFF</small> directory (see further below). -If the current scanline is past the end of the current -subfile, the <i>ImageLength</i> field is automatically -increased to include the scanline (except for -<i>PlanarConfiguration</i>=2, where the <i>ImageLength</i> -cannot be changed once the first data are written). If the -<i>ImageLength</i> is increased, the <i>StripOffsets</i> and -<i>StripByteCounts</i> fields are similarly enlarged to -reflect data written past the previous end of image.</p> -</td> -</table> -<a name="NOTES"></a> -<h2>NOTES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The library writes encoded data using the native machine -byte order. Correctly implemented <small>TIFF</small> -readers are expected to do any necessary byte-swapping to -correctly process image data with BitsPerSample greater than -8. The library attempts to hide bit-ordering differences -between the image and the native machine by converting data -from the native machine order.</p> -<!-- INDENTATION --> -<p>In C++ the <i>sample</i> parameter defaults to 0.</p> -<!-- INDENTATION --> -<p>Once data are written to a file for the current -directory, the values of certain tags may not be altered; -see <i>TIFFSetField</i>(3TIFF) for more information.</p> -<!-- INDENTATION --> -<p>It is not possible to write scanlines to a file that uses -a tiled organization. The routine <i>TIFFIsTiled</i> can be -used to determine if the file is organized as tiles or -strips.</p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFWriteScanline</i> returns −1 if it -immediately detects an error and 1 for a successful -write.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>All error messages are directed to the -<i>TIFFError</i>(3TIFF) routine.</p> -<!-- INDENTATION --> -<p><b>%s: File not open for writing .</b> The file was -opened for reading, not writing.</p> -<!-- INDENTATION --> -<p><b>Can not write scanlines to a tiled image</b>. An -attempt was made to write a scanline to a tiled image. The -image is assumed to be organized in tiles because the -<i>TileWidth</i> and <i>TileLength</i> tags have been set -with <i>TIFFSetField</i>(3TIFF).</p> -<!-- INDENTATION --> -<p><b>Compression algorithm does not support random -access</b>. Data was written in a non-sequential order to a -file that uses a compression algorithm and that has -<i>RowsPerStrip</i> greater than one. That is, data in the -image is to be stored in a compressed form, and with -multiple rows packed into a strip. In this case, the library -does not support random access to the data. The data should -either be written as entire strips, sequentially by rows, or -the value of <i>RowsPerStrip</i> should be set to one.</p> -<!-- INDENTATION --> -<p><b>%s: Must set "ImageWidth" before writing -data</b>. The image’s width has not be set before the -first write. See <b>TIFFSetField</b>(3TIFF) for information -on how to do this.</p> -<!-- INDENTATION --> -<p><b>%s: Must set "PlanarConfiguration" before -writing data</b>. The organization of data has not be -defined before the first write. See -<b>TIFFSetField</b>(3TIFF) for information on how to do -this.</p> -<!-- INDENTATION --> -<p><b>Can not change "ImageLength" when using -separate planes</b>. Separate image planes are being used -(<i>PlanarConfiguration</i>=2), but the number of rows has -not been specified before the first write. The library -supports the dynamic growth of an image only when data are -organized in a contiguous manner -(<i>PlanarConfiguration</i>=1).</p> -<!-- INDENTATION --> -<p><b>%d: Sample out of range, max %d</b>. The <i>sample</i> -parameter was greater than the value of the SamplesPerPixel -tag.</p> -<!-- INDENTATION --> -<p><b>%s: No space for strip arrays .</b> There was not -enough space for the arrays that hold strip offsets and byte -counts.</p> -</td> -</table> -<a name="BUGS"></a> -<h2>BUGS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Writing subsampled YCbCR data does not work correctly -because, for <i>PlanarConfiguration</i>=2 the size of a -scanline is not calculated on a per-sample basis, and for -<i>PlanarConfiguration</i>=1 the library does not pack the -block-interleaved samples.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>TIFFOpen</b>(3TIFF), -<b>TIFFWriteEncodedStrip</b>(3TIFF), -<b>TIFFWriteRawStrip</b>(3TIFF), <b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFWriteTile.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFWriteTile.3tiff.html deleted file mode 100644 index d6bc5d8..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFWriteTile.3tiff.html +++ /dev/null @@ -1,115 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:18 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFWriteTile</title> -</head> -<body> - -<h1 align=center>TIFFWriteTile</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#RETURN VALUES">RETURN VALUES</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFWriteTile − encode and write a tile of data to -an open <small>TIFF</small> file</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>tsize_t TIFFWriteTile(TIFF *</b><i>tif</i><b>, -tdata_t</b> <i>buf</i><b>, uint32</b> <i>x</i><b>, -uint32</b> <i>y</i><b>, uint32</b> <i>z</i><b>, -tsample_t</b> <i>sample</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Write the data for the tile <i>containing</i> the -specified coordinates. The data in <i>buf</i> are is -(potentially) compressed, and written to the indicated file, -normally being appended to the end of the file. The buffer -must be contain an entire tile of data. Applications should -call the routine <i>TIFFTileSize</i> to find out the size -(in bytes) of a tile buffer. The <i>x</i> and <i>y</i> -parameters are always used by <i>TIFFWriteTile</i>. The -<i>z</i> parameter is used if the image is deeper than 1 -slice (<i>ImageDepth</i>>1). The <i>sample</i> parameter -is used only if data are organized in separate planes -(<i>PlanarConfiguration</i>=2).</p> -</td> -</table> -<a name="RETURN VALUES"></a> -<h2>RETURN VALUES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFWriteTile</i> returns −1 if it detects an -error; otherwise the number of bytes in the tile is -returned.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>All error messages are directed to the -<b>TIFFError</b>(3TIFF) routine.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>TIFFCheckTile</b>(3TIFF), -<b>TIFFComputeTile</b>(3TIFF), <b>TIFFOpen</b>(3TIFF), -<b>TIFFReadTile</b>(3TIFF), <b>TIFFWriteScanline</b>(3TIFF), -<b>TIFFWriteEncodedTile</b>(3TIFF), -<b>TIFFWriteRawTile</b>(3TIFF), <b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFbuffer.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFbuffer.3tiff.html deleted file mode 100644 index 3d610ca..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFbuffer.3tiff.html +++ /dev/null @@ -1,116 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:14 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFBUFFER</title> -</head> -<body> - -<h1 align=center>TIFFBUFFER</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFReadBufferSetup, TIFFWriteBufferSetup − I/O -buffering control routines</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<pre><b>#include <tiffio.h> - -int TIFFReadBufferSetup(TIFF *</b><i>tif</i><b>, tdata_t</b> <i>buffer</i><b>, tsize_t</b> <i>size</i><b>); -int TIFFWriteBufferSetup(TIFF *</b><i>tif</i><b>, tdata_t</b> <i>buffer</i><b>, tsize_t</b> <i>size</i><b>); -</b></pre> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The following routines are provided for client-control of -the I/O buffers used by the library. Applications need never -use these routines; they are provided only for -‘‘intelligent clients’’ that wish to -optimize memory usage and/or eliminate potential copy -operations that can occur when working with images that have -data stored without compression.</p> -<!-- INDENTATION --> -<p><i>TIFFReadBufferSetup</i> sets up the data buffer used -to read raw (encoded) data from a file. If the specified -pointer is <small>NULL</small> (zero), then a buffer of the -appropriate size is allocated. Otherwise the caller must -guarantee that the buffer is large enough to hold any -individual strip of raw data. <i>TIFFReadBufferSetup</i> -returns a non-zero value if the setup was successful and -zero otherwise.</p> -<!-- INDENTATION --> -<p><i>TIFFWriteBufferSetup</i> sets up the data buffer used -to write raw (encoded) data to a file. If the specified -<i>size</i> is −1 then the buffer size is selected to -hold a complete tile or strip, or at least 8 kilobytes, -whichever is greater. If the specified <i>buffer</i> is -<small>NULL</small> (zero), then a buffer of the appropriate -size is dynamically allocated. <i>TIFFWriteBufferSetup</i> -returns a non-zero value if the setup was successful and -zero otherwise.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>%s: No space for data buffer at scanline %ld</b>. -<i>TIFFReadBufferSetup</i> was unable to dynamically -allocate space for a data buffer.</p> -<!-- INDENTATION --> -<p><b>%s: No space for output buffer</b>. -<i>TIFFWriteBufferSetup</i> was unable to dynamically -allocate space for a data buffer.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFcodec.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFcodec.3tiff.html deleted file mode 100644 index 8567b30..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFcodec.3tiff.html +++ /dev/null @@ -1,116 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:15 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>CODEC</title> -</head> -<body> - -<h1 align=center>CODEC</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFFindCODEC, TIFFRegisterCODEC, TIFFUnRegisterCODEC, -TIFFIsCODECConfigured − codec-related utility -routines</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>const TIFFCodec* TIFFFindCODEC(uint16</b> -<i>scheme</i><b>);<br> -TIFFCodec* TIFFRegisterCODEC(uint16</b> <i>scheme</i><b>, -const char *</b><i>method</i><b>, TIFFInitMethod</b> -<i>init</i><b>);<br> -void TIFFUnRegisterCODEC(TIFFCodec -*</b><i>codec</i><b>);<br> -int TIFFIsCODECConfigured(uint16</b> -<i>scheme</i><b>);</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>libtiff</i> supports a variety of compression schemes -implemented by software <i>codecs</i>. Each codec adheres to -a modular interface that provides for the decoding and -encoding of image data; as well as some other methods for -initialization, setup, cleanup, and the control of default -strip and tile sizes. Codecs are identified by the -associated value of the <small>TIFF</small> -<i>Compression</i> tag; e.g. 5 for <small>LZW</small> -compression.</p> -<!-- INDENTATION --> -<p>The <i>TIFFRegisterCODEC</i> routine can be used to -augment or override the set of codecs available to an -application. If the specified <i>scheme</i> already has a -registered codec then it is <i>overridden</i> and any images -with data encoded with this compression scheme will be -decoded using the supplied coded.</p> -<!-- INDENTATION --> -<p><i>TIFFIsCODECConfigured</i> returns 1 if the codec is -configured and working. Otherwise 0 will be returned.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>No space to register compression scheme %s</b>. -<i>TIFFRegisterCODEC</i> was unable to allocate memory for -the data structures needed to register a codec.</p> -<!-- INDENTATION --> -<p><b>Cannot remove compression scheme %s; not -registered</b>. <i>TIFFUnRegisterCODEC</i> did not locate -the specified codec in the table of registered compression -schemes.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFcolor.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFcolor.3tiff.html deleted file mode 100644 index 7e4eea5..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFcolor.3tiff.html +++ /dev/null @@ -1,975 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:15 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>COLOR</title> -</head> -<body> - -<h1 align=center>COLOR</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFYCbCrToRGBInit, TIFFYCbCrtoRGB, TIFFCIELabToRGBInit, -TIFFCIELabToXYZ, TIFFXYZToRGB − color conversion -routines.</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>int TIFFYCbCrToRGBInit(TIFFYCbCrToRGB -*</b><i>ycbcr</i><b>, float *</b><i>luma</i><b>, float -*</b><i>refBlackWhite"</i><b>);"<br> -void TIFFYCbCrtoRGB(TIFFYCbCrToRGB *</b><i>ycbcr</i><b>, -uint32</b> <i>Y</i><b>, int32</b> <i>Cb</i><b>, int32</b> -<i>Cr</i><b>, uint32 *</b><i>R</i><b>, uint32 -*</b><i>G</i><b>, uint32 *</b><i>B</i> <b>);</b></p> -<!-- INDENTATION --> -<p><b>int TIFFCIELabToRGBInit(TIFFCIELabToRGB -*</b><i>cielab</i><b>, TIFFDisplay *</b><i>display</i><b>, -float *</b><i>refWhite</i><b>);<br> -void TIFFCIELabToXYZ(TIFFCIELabToRGB *</b><i>cielab</i><b>, -uint32</b> <i>L</i><b>, int32</b> <i>a</i><b>, int32</b> -<i>b</i><b>, float *</b><i>X</i><b>, float *</b><i>Y</i><b>, -float *</b><i>Z</i><b>);<br> -void TIFFXYZToRGB(TIFFCIELabToRGB *</b><i>cielab</i><b>, -float</b> <i>X</i><b>, float</b> <i>Y</i><b>, float</b> -<i>Z"</i><b>,</b><i>uint32</i><b>*"</b><i>R</i><b>, -uint32 *</b><i>G</i><b>, uint32 *</b><i>B</i><b>);</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFF supports several color spaces for images stored in -that format. There is usually a problem of application to -handle the data properly and convert between different -colorspaces for displaying and printing purposes. To -simplify this task libtiff implements several color -conversion routines itself. In particular, these routines -used in <b>TIFFRGBAImage(3TIFF)</b> interface.</p> -<!-- INDENTATION --> -<p><b>TIFFYCbCrToRGBInit()</b> used to initialize -<i>YCbCr</i> to <i>RGB</i> conversion state. Allocating and -freeing of the <i>ycbcr</i> structure belongs to programmer. -<i>TIFFYCbCrToRGB</i> defined in <b>tiffio.h</b> as</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>typedef struct { /* YCbCr->RGB support */ - TIFFRGBValue* clamptab; /* range clamping table */ -</pre> -</td> -</table> -<!-- TABS --> - -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> - -<p>int*</p> -<td width="28%"></td> -<td width="-3%"></td> -<td width="12%"></td> -<td width="6%"> - -<p>Cr_r_tab;<br> -int*</p> -</td> -<td width="56%"> -</td> -<tr valign="top" align="left"> -<td width="28%"></td> -<td width="-3%"></td> -<td width="12%"></td> -<td width="6%"> - -<p>Cb_b_tab;<br> -int32*</p> -</td> -<td width="56%"> -</td> -<tr valign="top" align="left"> -<td width="28%"></td> -<td width="-3%"></td> -<td width="12%"></td> -<td width="6%"> - -<p>Cr_g_tab;<br> -int32*</p> -</td> -<td width="56%"> -</td> -<tr valign="top" align="left"> -<td width="28%"></td> -<td width="-3%"></td> -<td width="12%"></td> -<td width="6%"> - -<p>Cb_g_tab;</p> -</td> -<td width="56%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<p>int32* Y_tab;<br> -} TIFFYCbCrToRGB;</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>luma</i> is a float array of three values representing -proportions of the red, green and blue in luminance, Y (see -section 21 of the TIFF 6.0 specification, where the YCbCr -images discussed). <i>TIFFTAG_YCBCRCOEFFICIENTS</i> holds -that values in TIFF file. <i>refBlackWhite</i> is a float -array of 6 values which specifies a pair of headroom and -footroom image data values (codes) for each image component -(see section 20 of the TIFF 6.0 specification where the -colorinmetry fields discussed). -<i>TIFFTAG_REFERENCEBLACKWHITE</i> is responsible for -storing these values in TIFF file. Following code snippet -should helps to understand the the technique:</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>float *luma, *refBlackWhite; -uint16 hs, vs; - -/* Initialize structures */ -ycbcr = (TIFFYCbCrToRGB*) -</pre> -</td> -</table> -<!-- TABS --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="75%"> - -<p>_TIFFmalloc(TIFFroundup(sizeof(TIFFYCbCrToRGB), -sizeof(long))</p> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="75%"> - -<p>+ 4*256*sizeof(TIFFRGBValue)</p> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="75%"> - -<p>+ 2*256*sizeof(int)</p> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="75%"> - -<p>+ 3*256*sizeof(int32));</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<p>if (ycbcr == NULL) {<br> -TIFFError("YCbCr->RGB",</p></td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="4" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="6%"> -</td> -<td width="6%"> - -<p>"No space for YCbCr->RGB conversion -state");</p> -</td> -<td width="62%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<p>exit(0);<br> -}</p> -<!-- INDENTATION --> -<p>TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRCOEFFICIENTS, -&luma);<br> -TIFFGetFieldDefaulted(tif, TIFFTAG_REFERENCEBLACKWHITE, -&refBlackWhite);<br> -if (TIFFYCbCrToRGBInit(ycbcr, luma, refBlackWhite) < -0)</p></td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="75%"> - -<p>exit(0);</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<p>/* Start conversion */<br> -uint32 r, g, b;<br> -uint32 Y;<br> -int32 Cb, Cr;</p> -<!-- INDENTATION --> -<p>for each pixel in image</p></td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="75%"> - -<p>TIFFYCbCrtoRGB(img->ycbcr, Y, Cb, Cr, &r, &g, -&b);</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<p>/* Free state structure */<br> -_TIFFfree(ycbcr);</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>TIFFCIELabToRGBInit()</b> initializes the <i>CIE -L*a*b* 1976</i> to <i>RGB</i> conversion state. -<b>TIFFCIELabToRGB</b> defined as</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>#define CIELABTORGB_TABLE_RANGE 1500 - -</pre> -</td> -</table> -<!-- TABS --> - -<table width="100%" border=0 rules="none" frame="void" - cols="9" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="6%"> - -<p>typedef struct {</p> -</td> -<td width="6%"></td> -<td width="6%"></td> -<td width="6%"></td> -<td width="6%"> -</td> -<td width="6%"> - -<p>/* CIE Lab 1976->RGB support */</p> -</td> -<td width="6%"></td> -<td width="37%"> -</td> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="6%"> -</td> -<td width="6%"> - -<p>int</p> -</td> -<td width="6%"> - -<p>range;</p> -</td> -<td width="6%"></td> -<td width="6%"> -</td> -<td width="6%"> - -<p>/* Size of conversion table */</p> -</td> -<td width="6%"></td> -<td width="37%"> -</td> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="6%"> -</td> -<td width="6%"> - -<p>float</p> -</td> -<td width="6%"></td> -<td width="6%"> - -<p>rstep, gstep, bstep;</p> -</td> -<td width="6%"></td> -<td width="6%"></td> -<td width="6%"></td> -<td width="37%"> -</td> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="6%"> -</td> -<td width="6%"> - -<p>float</p> -</td> -<td width="6%"></td> -<td width="6%"> - -<p>X0, Y0, Z0;</p> -</td> -<td width="6%"></td> -<td width="6%"></td> -<td width="6%"> - -<p>/* Reference white point */</p> -</td> -<td width="37%"> -</td> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="6%"></td> -<td width="6%"> - -<p>TIFFDisplay display;</p> -</td> -<td width="6%"></td> -<td width="6%"></td> -<td width="6%"></td> -<td width="6%"></td> -<td width="6%"></td> -<td width="37%"> -</td> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="6%"> -</td> -<td width="6%"> - -<p>float</p> -</td> -<td width="6%"></td> -<td width="6%"> - -<p>Yr2r[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yr -to r */</p> -</td> -<td width="6%"></td> -<td width="6%"></td> -<td width="6%"></td> -<td width="37%"> -</td> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="6%"> -</td> -<td width="6%"> - -<p>float</p> -</td> -<td width="6%"></td> -<td width="6%"> - -<p>Yg2g[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yg -to g */</p> -</td> -<td width="6%"></td> -<td width="6%"></td> -<td width="6%"></td> -<td width="37%"> -</td> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="6%"> -</td> -<td width="6%"> - -<p>float</p> -</td> -<td width="6%"></td> -<td width="6%"> - -<p>Yb2b[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yb -to b */</p> -</td> -<td width="6%"></td> -<td width="6%"></td> -<td width="6%"></td> -<td width="37%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<p>} TIFFCIELabToRGB;</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>display</i> is a display device description, declared -as</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>typedef struct { -</pre> -</td> -</table> -<!-- TABS --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="75%"> - -<p>float d_mat[3][3]; /* XYZ -> luminance matrix */</p> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="75%"> - -<p>float d_YCR; /* Light o/p for reference white */</p> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="75%"> - -<p>float d_YCG;</p> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="75%"> - -<p>float d_YCB;</p> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="75%"> - -<p>uint32 d_Vrwr; /* Pixel values for ref. white */</p> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="75%"> - -<p>uint32 d_Vrwg;</p> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="75%"> - -<p>uint32 d_Vrwb;</p> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="75%"> - -<p>float d_Y0R; /* Residual light for black pixel */</p> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="75%"> - -<p>float d_Y0G;</p> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="75%"> - -<p>float d_Y0B;</p> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="75%"> - -<p>float d_gammaR; /* Gamma values for the three guns -*/</p> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="75%"> - -<p>float d_gammaG;</p> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="75%"> - -<p>float d_gammaB;</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<p>} TIFFDisplay;</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>For example, the one can use sRGB device, which has the -following parameters:</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>TIFFDisplay display_sRGB = { -</pre> -</td> -</table> -<!-- TABS --> - -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="0%"></td> -<td width="6%"> - -<p>{ /* XYZ -> luminance matrix */</p> -</td> -<td width="6%"></td> -<td width="62%"> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="0%"></td> -<td width="6%"> -</td> -<td width="6%"> - -<p>{ 3.2410F, -1.5374F, -0.4986F },</p> -</td> -<td width="62%"> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="0%"></td> -<td width="6%"> -</td> -<td width="6%"> - -<p>{ -0.9692F, 1.8760F, 0.0416F },</p> -</td> -<td width="62%"> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="0%"></td> -<td width="6%"> -</td> -<td width="6%"> - -<p>{ 0.0556F, -0.2040F, 1.0570F }</p> -</td> -<td width="62%"> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="0%"></td> -<td width="6%"> - -<p>},</p> -</td> -<td width="6%"> -</td> -<td width="62%"> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="0%"></td> -<td width="6%"> - -<p>100.0F, 100.0F, 100.0F, /* Light o/p for reference white -*/</p> -</td> -<td width="6%"></td> -<td width="62%"> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="0%"></td> -<td width="6%"> - -<p>255, 255, 255, /* Pixel values for ref. white */</p> -</td> -<td width="6%"></td> -<td width="62%"> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="0%"></td> -<td width="6%"> - -<p>1.0F, 1.0F, 1.0F, /* Residual light o/p for black pixel -*/</p> -</td> -<td width="6%"></td> -<td width="62%"> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="0%"></td> -<td width="6%"> - -<p>2.4F, 2.4F, 2.4F, /* Gamma values for the three guns -*/</p> -</td> -<td width="6%"></td> -<td width="62%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<p>};</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>refWhite</i> is a color temperature of the reference -white. The <i>TIFFTAG_WHITEPOINT</i> contains the -chromaticity of the white point of the image from where the -reference white can be calculated using following -formulae:</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<p>refWhite_Y = 100.0<br> -refWhite_X = whitePoint_x / whitePoint_y * refWhite_Y<br> -refWhite_Z = (1.0 - whitePoint_x - whitePoint_y) / -whitePoint_y * refWhite_X</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The conversion itself performed in two steps: at the -first one we will convert <i>CIE L*a*b* 1976</i> to <i>CIE -XYZ</i> using <b>TIFFCIELabToXYZ()</b> routine, and at the -second step we will convert <i>CIE XYZ</i> to <i>RGB</i> -using <b>TIFFXYZToRGB().</b> Look at the code sample -below:</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>float *whitePoint; -float refWhite[3]; - -/* Initialize structures */ -img->cielab = (TIFFCIELabToRGB *) -</pre> -</td> -</table> -<!-- TABS --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="75%"> - -<p>_TIFFmalloc(sizeof(TIFFCIELabToRGB));</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<p>if (!cielab) {</p></td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="0%"></td> -<td width="6%"> - -<p>TIFFError("CIE L*a*b*->RGB",</p> -</td> -<td width="6%"></td> -<td width="62%"> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="0%"></td> -<td width="6%"> -</td> -<td width="6%"> - -<p>"No space for CIE L*a*b*->RGB conversion -state.");</p> -</td> -<td width="62%"> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="0%"></td> -<td width="6%"> - -<p>exit(0);</p> -</td> -<td width="6%"></td> -<td width="62%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<p>}</p> -<!-- INDENTATION --> -<p>TIFFGetFieldDefaulted(tif, TIFFTAG_WHITEPOINT, -&whitePoint);<br> -refWhite[1] = 100.0F;<br> -refWhite[0] = whitePoint[0] / whitePoint[1] * -refWhite[1];<br> -refWhite[2] = (1.0F - whitePoint[0] - -whitePoint[1])</p></td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="75%"> - -<p>/ whitePoint[1] * refWhite[1];</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<p>if (TIFFCIELabToRGBInit(cielab, &display_sRGB, -refWhite) < 0) {</p></td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="0%"></td> -<td width="6%"> - -<p>TIFFError("CIE L*a*b*->RGB",</p> -</td> -<td width="6%"></td> -<td width="62%"> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="0%"></td> -<td width="6%"> -</td> -<td width="6%"> - -<p>"Failed to initialize CIE L*a*b*->RGB conversion -state.");</p> -</td> -<td width="62%"> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="0%"></td> -<td width="6%"> - -<p>_TIFFfree(cielab);</p> -</td> -<td width="6%"></td> -<td width="62%"> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="0%"></td> -<td width="6%"> - -<p>exit(0);</p> -</td> -<td width="6%"></td> -<td width="62%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<p>}</p> -<!-- INDENTATION --> -<p>/* Now we can start to convert */<br> -uint32 r, g, b;<br> -uint32 L;<br> -int32 a, b;<br> -float X, Y, Z;</p> -<!-- INDENTATION --> -<p>for each pixel in image</p></td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="75%"> - -<p>TIFFCIELabToXYZ(cielab, L, a, b, &X, &Y, -&Z);</p> -</td> -<tr valign="top" align="left"> -<td width="24%"></td> -<td width="75%"> - -<p>TIFFXYZToRGB(cielab, X, Y, Z, &r, &g, -&b);</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<p>/* Don’t forget to free the state structure */<br> -_TIFFfree(cielab);</p></td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>TIFFRGBAImage</b>(3TIFF) <b>libtiff</b>(3TIFF),</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFmemory.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFmemory.3tiff.html deleted file mode 100644 index 746b5ec..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFmemory.3tiff.html +++ /dev/null @@ -1,110 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:15 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>MEMORY</title> -</head> -<body> - -<h1 align=center>MEMORY</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>_TIFFmalloc, _TIFFrealloc, _TIFFfree, _TIFFmemset, -_TIFFmemcpy, _TIFFmemcmp, − memory management-related -functions for use with <small>TIFF</small> files</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>tdata_t _TIFFmalloc(tsize_t</b> <i>size</i><b>);<br> -tdata_t _TIFFrealloc(tdata_t</b> <i>buffer</i><b>, -tsize_t</b> <i>size</i><b>);<br> -void _TIFFfree(tdata_t</b> <i>buffer</i><b>);<br> -void _TIFFmemset(tdata_t</b> <i>s</i><b>, int</b> -<i>c</i><b>, tsize_t</b> <i>n</i><b>);<br> -void _TIFFmemcpy(tdata_t</b> <i>dest</i><b>, const -tdata_t</b> <i>src</i><b>, tsize_t</b> <i>n</i><b>);<br> -int _TIFFmemcmp(const tdata_t</b> <i>s1</i><b>, const -tdata_t</b> <i>s2</i><b>, tsize_t</b> <i>n</i><b>);</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>These routines are provided for writing portable software -that uses <i>libtiff</i>; they hide any memory-management -related issues, such as dealing with segmented architectures -found on 16-bit machines.</p> -<!-- INDENTATION --> -<p><i>_TIFFmalloc</i> and <i>_TIFFrealloc</i> are used to -dynamically allocate and reallocate memory used by -<i>libtiff</i>; such as memory passed into the I/O routines. -Memory allocated through these interfaces is released back -to the system using the <i>_TIFFfree</i> routine.</p> -<!-- INDENTATION --> -<p>Memory allocated through one of the above interfaces can -be set to a known value using <i>_TIFFmemset</i>, copied to -another memory location using <i>_TIFFmemcpy</i>, or -compared for equality using <i>_TIFFmemcmp</i>. These -routines conform to the equivalent <small>ANSI</small> C -routines: <i>memset</i>, <i>memcpy</i>, and <i>memcmp</i>, -repsectively.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>None.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>malloc</b>(3), <b>memory</b>(3), -<b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFquery.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFquery.3tiff.html deleted file mode 100644 index e27354a..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFquery.3tiff.html +++ /dev/null @@ -1,148 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:15 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>QUERY</title> -</head> -<body> - -<h1 align=center>QUERY</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFCurrentRow, TIFFCurrentStrip, TIFFCurrentTile, -TIFFCurrentDirectory, TIFFLastDirectory, TIFFFileno, -TIFFFileName, TIFFGetMode, TIFFIsTiled, TIFFIsByteSwapped, -TIFFIsUpSampled, TIFFIsMSB2LSB, TIFFGetVersion − query -routines</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>uint32 TIFFCurrentRow(TIFF*</b> <i>tif</i><b>)<br> -tstrip_t TIFFCurrentStrip(TIFF*</b> <i>tif</i><b>)<br> -ttile_t TIFFCurrentTile(TIFF*</b> <i>tif</i><b>)<br> -tdir_t TIFFCurrentDirectory(TIFF*</b> <i>tif</i><b>)<br> -int TIFFLastDirectory(TIFF*</b> <i>tif</i><b>)<br> -int TIFFFileno(TIFF*</b> <i>tif</i><b>)<br> -char* TIFFFileName(TIFF*</b> <i>tif</i><b>)<br> -int TIFFGetMode(TIFF*</b> <i>tif</i><b>)<br> -int TIFFIsTiled(TIFF*</b> <i>tif</i><b>)<br> -int TIFFIsByteSwapped(TIFF*</b> <i>tif</i><b>)<br> -int TIFFIsUpSampled(TIFF*</b> <i>tif</i><b>)<br> -int TIFFIsMSB2LSB(TIFF*</b> <i>tif</i><b>)<br> -const char* TIFFGetVersion(void)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The following routines return status information about an -open <small>TIFF</small> file.</p> -<!-- INDENTATION --> -<p><i>TIFFCurrentDirectory</i> returns the index of the -current directory (directories are numbered starting at 0). -This number is suitable for use with the -<i>TIFFSetDirectory</i> routine.</p> -<!-- INDENTATION --> -<p><i>TIFFLastDirectory</i> returns a non-zero value if the -current directory is the last directory in the file; -otherwise zero is returned.</p> -<!-- INDENTATION --> -<p><i>TIFFCurrentRow</i>, <i>TIFFCurrentStrip</i>, and -<i>TIFFCurrentTile</i>, return the current row, strip, and -tile, respectively, that is being read or written. These -values are updated each time a read or write is done.</p> -<!-- INDENTATION --> -<p><i>TIFFFileno</i> returns the underlying file descriptor -used to access the <small>TIFF</small> image in the -filesystem.</p> -<!-- INDENTATION --> -<p><i>TIFFFileName</i> returns the pathname argument passed -to <i>TIFFOpen</i> or <i>TIFFFdOpen</i>.</p> -<!-- INDENTATION --> -<p><i>TIFFGetMode</i> returns the mode with which the -underlying file was opened. On <small>UNIX</small> systems, -this is the value passed to the <i>open</i>(2) system -call.</p> -<!-- INDENTATION --> -<p><i>TIFFIsTiled</i> returns a non-zero value if the image -data has a tiled organization. Zero is returned if the image -data is organized in strips.</p> -<!-- INDENTATION --> -<p><i>TIFFIsByteSwapped</i> returns a non-zero value if the -image data was in a different byte-order than the host -machine. Zero is returned if the TIFF file and local host -byte-orders are the same. Note that TIFFReadTile(), -TIFFReadStrip() and TIFFReadScanline() functions already -normally perform byte swapping to local host order if -needed.</p> -<!-- INDENTATION --> -<p><i>TIFFIsUpSampled</i> returns a non-zero value if image -data returned through the read interface routines is being -up-sampled. This can be useful to applications that want to -calculate I/O buffer sizes to reflect this usage (though the -usual strip and tile size routines already do this).</p> -<!-- INDENTATION --> -<p><i>TIFFIsMSB2LSB</i> returns a non-zero value if the -image data is being returned with bit 0 as the most -significant bit.</p> -<!-- INDENTATION --> -<p><i>TIFFGetVersion</i> returns an <small>ASCII</small> -string that has a version stamp for the <small>TIFF</small> -library software.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>None.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>libtiff</i>(3TIFF), <i>TIFFOpen</i>(3TIFF), -<i>TIFFFdOpen</i>(3TIFF)</p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFsize.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFsize.3tiff.html deleted file mode 100644 index 54fb71b..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFsize.3tiff.html +++ /dev/null @@ -1,95 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:17 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFSIZE</title> -</head> -<body> - -<h1 align=center>TIFFSIZE</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFScanlineSize, TIFFRasterScanlineSize, − return -the size of various items associated with an open -<small>TIFF</small> file</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>tsize_t TIFFRasterScanlineSize(TIFF -*</b><i>tif</i><b>)<br> -tsize_t TIFFScanlineSize(TIFF *</b><i>tif</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFScanlineSize</i> returns the size in bytes of a -row of data as it would be returned in a call to -<i>TIFFReadScanline</i>, or as it would be expected in a -call to <i>TIFFWriteScanline</i>.</p> -<!-- INDENTATION --> -<p><i>TIFFRasterScanlineSize</i> returns the size in bytes -of a complete decoded and packed raster scanline. Note that -this value may be different from the value returned by -<i>TIFFScanlineSize</i> if data is stored as separate -planes.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>None.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>TIFFOpen</b>(3TIFF), <b>TIFFReadScanline</b>(3TIFF), -<b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFstrip.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFstrip.3tiff.html deleted file mode 100644 index a0fc358..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFstrip.3tiff.html +++ /dev/null @@ -1,129 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:17 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFSTRIP</title> -</head> -<body> - -<h1 align=center>TIFFSTRIP</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFDefaultStripSize, TIFFStripSize, TIFFVStripSize, -TIFFRawStripSize, TIFFComputeStrip, TIFFNumberOfStrips -− strip-related utility routines</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>uint32 TIFFDefaultStripSize(TIFF *</b><i>tif</i><b>, -uint32</b> <i>estimate</i><b>)<br> -tsize_t TIFFStripSize(TIFF *</b><i>tif</i><b>)<br> -tsize_t TIFFVStripSize(TIFF *</b><i>tif</i><b>, uint32</b> -<i>nrows</i><b>)<br> -tsize_t TIFFRawStripSize(TIFF *</b><i>tif</i><b>, -tstrip_t</b> <i>strip</i><b>)<br> -tstrip_t TIFFComputeStrip(TIFF *</b><i>tif</i><b>, -uint32</b> <i>row</i><b>, tsample_t</b> -<i>sample</i><b>)<br> -tstrip_t TIFFNumberOfStrips(TIFF *</b><i>tif</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFDefaultStripSize</i> returns the number of rows -for a reasonable-sized strip according to the current -settings of the <i>ImageWidth</i>, <i>BitsPerSample</i>, -<i>SamplesPerPixel</i>, tags and any compression-specific -requirements. If the <i>estimate</i> parameter, if non-zero, -then it is taken as an estimate of the desired strip size -and adjusted according to any compression-specific -requirements. The value returned by this function is -typically used to define the <i>RowsPerStrip</i> tag. In -lieu of any unusual requirements <i>TIFFDefaultStripSize</i> -tries to create strips that have approximately 8 kilobytes -of uncompressed data.</p> -<!-- INDENTATION --> -<p><i>TIFFStripSize</i> returns the equivalent size for a -strip of data as it would be returned in a call to -<i>TIFFReadEncodedStrip</i> or as it would be expected in a -call to <i>TIFFWriteEncodedStrip</i>.</p> -<!-- INDENTATION --> -<p><i>TIFFVStripSize</i> returns the number of bytes in a -strip with <i>nrows</i> rows of data.</p> -<!-- INDENTATION --> -<p><i>TIFFRawStripSize</i> returns the number of bytes in a -raw strip (i.e. not decoded).</p> -<!-- INDENTATION --> -<p><i>TIFFComputeStrip</i> returns the strip that contains -the specified coordinates. A valid strip is always returned; -out-of-range coordinate values are clamped to the bounds of -the image. The <i>row</i> parameter is always used in -calculating a strip. The <i>sample</i> parameter is used -only if data are organized in separate planes -(<i>PlanarConfiguration</i>=2).</p> -<!-- INDENTATION --> -<p><i>TIFFNumberOfStrips</i> returns the number of strips in -the image.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>None.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>TIFFReadEncodedStrip</b>(3TIFF), -<b>TIFFReadRawStrip</b>(3TIFF), -<b>TIFFWriteEncodedStrip</b>(3TIFF), -<b>TIFFWriteRawStrip</b>(3TIFF), <b>libtiff</b>(3TIFF),</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFswab.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFswab.3tiff.html deleted file mode 100644 index 2924a38..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFswab.3tiff.html +++ /dev/null @@ -1,110 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:17 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>SWAB</title> -</head> -<body> - -<h1 align=center>SWAB</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFGetBitRevTable, TIFFReverseBits, TIFFSwabShort, -TIFFSwabLong, TIFFSwabArrayOfShort, TIFFSwabArrayOfLong -− byte- and bit-swapping routines</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>const unsigned char* TIFFGetBitRevTable(int</b> -<i>reversed</i><b>)<br> -void TIFFReverseBits(u_char *</b><i>data</i><b>, unsigned -long</b> <i>nbytes</i><b>)<br> -void TIFFSwabShort(uint16 *</b><i>data</i><b>)<br> -void TIFFSwabLong(uint32 *</b><i>data</i><b>)<br> -void TIFFSwabArrayOfShort(uint16 *</b><i>data</i><b>, -unsigned long</b> <i>nshorts</i><b>)<br> -void TIFFSwabArrayOfLong(uint32 *</b><i>data</i><b>, -unsigned long</b> <i>nlongs</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The following routines are used by the library to swap -16- and 32-bit data and to reverse the order of bits in -bytes.</p> -<!-- INDENTATION --> -<p><i>TIFFSwabShort</i> and <i>TIFFSwabLong</i> swap the -bytes in a single 16-bit and 32-bit item, respectively. -<i>TIFFSwabArrayOfShort</i> and <i>TIFFSwabArrayOfLong</i> -swap the bytes in an array of 16-bit and 32-bit items, -respectively.</p> -<!-- INDENTATION --> -<p><i>TIFFReverseBits</i> replaces each byte in <i>data</i> -with the equivalent bit-reversed value. This operation is -performed with a lookup table, which is returned using the -<i>TIFFGetBitRevTable</i> function. <i>reversed</i> -parameter specifies which table should be returned. Supply -<i>1</i> if you want bit reversal table. Supply <i>0</i> to -get the table that do not reverse bit values. It is a lookup -table that can be used as an <i>identity function</i>; i.e. -<i>TIFFNoBitRevTable[n] == n</i>.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>None.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/TIFFtile.3tiff.html b/src/3rdparty/libtiff/html/man/TIFFtile.3tiff.html deleted file mode 100644 index e8e0008..0000000 --- a/src/3rdparty/libtiff/html/man/TIFFtile.3tiff.html +++ /dev/null @@ -1,141 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:17 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFTILE</title> -</head> -<body> - -<h1 align=center>TIFFTILE</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>TIFFTileSize, TIFFTileRowSize, TIFFVTileSize, -TIFFDefaultTileSize, TIFFComputeTile, TIFFCheckTile, -TIFFNumberOfTiles − tile-related utility routines</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>#include <tiffio.h></b></p> -<!-- INDENTATION --> -<p><b>void TIFFDefaultTileSize(TIFF *</b><i>tif</i><b>, -uint32 *</b><i>tw</i><b>, uint32 *</b><i>th</i><b>)<br> -tsize_t TIFFTileSize(TIFF *</b><i>tif</i><b>)<br> -tsize_t TIFFTileRowSize(TIFF *</b><i>tif</i><b>)<br> -tsize_t TIFFVTileSize(TIFF *</b><i>tif</i><b>, uint32</b> -<i>nrows</i><b>)<br> -ttile_t TIFFComputeTile(TIFF *</b><i>tif</i><b>, uint32</b> -<i>x</i><b>, uint32</b> <i>y</i><b>, uint32</b> <i>z</i><b>, -tsample_t</b> <i>sample</i><b>)<br> -int TIFFCheckTile(TIFF *</b><i>tif</i><b>, uint32</b> -<i>x</i><b>, uint32</b> <i>y</i><b>, uint32</b> <i>z</i><b>, -tsample_t</b> <i>sample</i><b>)<br> -ttile_t TIFFNumberOfTiles(TIFF *</b><i>tif</i><b>)</b></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>TIFFDefaultTileSize</i> returns the pixel width and -height of a reasonable-sized tile; suitable for setting up -the <i>TileWidth</i> and <i>TileLength</i> tags. If the -<i>tw</i> and <i>th</i> values passed in are non-zero, then -they are adjusted to reflect any compression-specific -requirements. The returned width and height are constrained -to be a multiple of 16 pixels to conform with the -<small>TIFF</small> specification.</p> -<!-- INDENTATION --> -<p><i>TIFFTileSize</i> returns the equivalent size for a -tile of data as it would be returned in a call to -<i>TIFFReadTile</i> or as it would be expected in a call to -<i>TIFFWriteTile</i>.</p> -<!-- INDENTATION --> -<p><i>TIFFVTileSize</i> returns the number of bytes in a -row-aligned tile with <i>nrows</i> of data.</p> -<!-- INDENTATION --> -<p><i>TIFFTileRowSize</i> returns the number of bytes of a -row of data in a tile.</p> -<!-- INDENTATION --> -<p><i>TIFFComputeTile</i> returns the tile that contains the -specified coordinates. A valid tile is always returned; -out-of-range coordinate values are clamped to the bounds of -the image. The <i>x</i> and <i>y</i> parameters are always -used in calculating a tile. The <i>z</i> parameter is used -if the image is deeper than 1 slice -(<i>ImageDepth</i>>1). The <i>sample</i> parameter is -used only if data are organized in separate planes -(<i>PlanarConfiguration</i>=2).</p> -<!-- INDENTATION --> -<p><i>TIFFCheckTile</i> returns a non-zero value if the -supplied coordinates are within the bounds of the image and -zero otherwise. The <i>x</i> parameter is checked against -the value of the <i>ImageWidth</i> tag. The <i>y</i> -parameter is checked against the value of the -<i>ImageLength</i> tag. The <i>z</i> parameter is checked -against the value of the <i>ImageDepth</i> tag (if defined). -The <i>sample</i> parameter is checked against the value of -the <i>SamplesPerPixel</i> parameter if the data are -organized in separate planes.</p> -<!-- INDENTATION --> -<p><i>TIFFNumberOfTiles</i> returns the number of tiles in -the image.</p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>None.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>TIFFReadEncodedTile</b>(3TIFF), -<b>TIFFReadRawTile</b>(3TIFF), <b>TIFFReadTile</b>(3TIFF), -<b>TIFFWriteEncodedTile</b>(3TIFF), -<b>TIFFWriteRawTile</b>(3TIFF), <b>TIFFWriteTile</b>(3TIFF), -<b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/fax2ps.1.html b/src/3rdparty/libtiff/html/man/fax2ps.1.html deleted file mode 100644 index c539614..0000000 --- a/src/3rdparty/libtiff/html/man/fax2ps.1.html +++ /dev/null @@ -1,252 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:18 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>FAX2PS</title> -</head> -<body> - -<h1 align=center>FAX2PS</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#NOTES">NOTES</a><br> -<a href="#BUGS">BUGS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>fax2ps − convert a <small>TIFF</small> facsimile to -compressed PostScript™</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>fax2ps</b> [ <i>options</i> ] [ <i>file ...</i> ]</p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>fax2ps</i> reads one or more <small>TIFF</small> -facsimile image files and prints a compressed form of -PostScript on the standard output that is suitable for -printing.</p> -<!-- INDENTATION --> -<p>By default, each page is scaled to reflect the image -dimensions and resolutions stored in the file. The -<b>−x</b> and <b>−y</b> options can be used to -specify the horizontal and vertical image resolutions -(lines/inch), respectively. If the <b>−S</b> option is -specified, each page is scaled to fill an output page. The -default output page is 8.5 by 11 inches. Alternate page -dimensions can be specified in inches with the -<b>−W</b> and <b>−H</b> options.</p> -<!-- INDENTATION --> -<p>By default <i>fax2ps</i> generates PostScript for all -pages in the file. The <b>−p</b> option can be used to -select one or more pages from a multi-page document.</p> -<!-- INDENTATION --> -<p><i>fax2ps</i> generates a compressed form of PostScript -that is optimized for sending pages of text to a PostScript -printer attached to a host through a low-speed link (such as -a serial line). Each output page is filled with white and -then only the black areas are drawn. The PostScript -specification of the black drawing operations is optimized -by using a special font that encodes the move-draw -operations required to fill the black regions on the page. -This compression scheme typically results in a substantially -reduced PostScript description, relative to the -straightforward imaging of the page with a PostScript -<i>image</i> operator. This algorithm can, however, be -ineffective for continuous-tone and white-on-black images. -For these images, it sometimes is more efficient to send the -raster bitmap image directly; see <b>tiff2ps</b>(1).</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="4" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="11%"></td> -<td width="11%"> - -<p><b>−p</b> <i>number</i></p> -</td> -<td width="76%"> - -<p>Print only the indicated page. Multiple pages may be -printed by specifying this option more than once.</p> -</td> -<td width="0%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−x</b> <i>resolution</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="23%"></td> -<td width="76%"> -<p>Use <i>resolution</i> as the horizontal resolution, in -dots/inch, of the image data. By default this value is taken -from the file.</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−y</b> <i>resolution</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="23%"></td> -<td width="76%"> -<p>Use <i>resolution</i> as the vertical resolution, in -lines/inch, of the image data. By default this value is -taken from the file.</p> -</td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="4" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="12%"> - -<p><b>−S</b></p> -</td> -<td width="76%"> - -<p>Scale each page of image data to fill the output page -dimensions. By default images are presented according to the -dimension information recorded in the <small>TIFF</small> -file.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="12%"> - -<p><b>−W</b> <i>width</i></p> -</td> -<td width="76%"> - -<p>Use <i>width</i> as the width, in inches, of the output -page.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="12%"> - -<p><b>−H</b> <i>height</i></p> -</td> -<td width="76%"> - -<p>Use <i>height</i> as the height, in inches, of the -output page.</p> -</td> -<td width="0%"> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Some messages about malformed <small>TIFF</small> images -come from the <small>TIFF</small> library.</p> -<!-- INDENTATION --> -<p>Various messages about badly formatted facsimile images -may be generated due to transmission errors in received -facsimile. <i>fax2ps</i> attempts to recover from such data -errors by resynchronizing decoding at the end of the current -scanline. This can result in long horizontal black lines in -the resultant PostScript image.</p> -</td> -</table> -<a name="NOTES"></a> -<h2>NOTES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>If the destination printer supports PostScript Level II -then it is always faster to just send the encoded bitmap -generated by the <b>tiff2ps</b>(1) program.</p> -</td> -</table> -<a name="BUGS"></a> -<h2>BUGS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>fax2ps</i> should probably figure out when it is doing -a poor job of compressing the output and just generate -PostScript to image the bitmap raster instead.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiff2ps</b>(1), <b>libtiff</b>(3)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/fax2tiff.1.html b/src/3rdparty/libtiff/html/man/fax2tiff.1.html deleted file mode 100644 index 38b54c0..0000000 --- a/src/3rdparty/libtiff/html/man/fax2tiff.1.html +++ /dev/null @@ -1,607 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:18 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>FAX2TIFF</title> -</head> -<body> - -<h1 align=center>FAX2TIFF</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#BUGS">BUGS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>fax2tiff − create a <small>TIFF</small> Class F fax -file from raw fax data</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>fax2tiff</b> [ <i>options</i> ] [ <b>−o</b> -<i>output.tif</i> ] <i>input.raw</i></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>Fax2tiff</i> creates a <small>TIFF</small> file -containing <small>CCITT</small> Group 3 or Group 4 encoded -data from one or more files containing -‘‘raw’’ Group 3 or Group 4 encoded -data (typically obtained directly from a fax modem). By -default, each row of data in the resultant -<small>TIFF</small> file is 1-dimensionally encoded and -padded or truncated to 1728 pixels, as needed. The resultant -image is a set of low resolution (98 lines/inch) or medium -resolution (196 lines/inch) pages, each of which is a single -strip of data. The generated file conforms to the -<small>TIFF</small> Class F ( <small>FAX</small> ) -specification for storing facsimile data. This means, in -particular, that each page of the data does <b>not</b> -include the trailing <i>return to control</i> ( -<small>RTC</small> ) code; as required for transmission by -the <small>CCITT</small> Group 3 specifications. The old, -‘‘classic’’, format is created if -the <b>−c</b> option is used. (The Class F format can -also be requested with the <b>−f</b> option.)</p> -<!-- INDENTATION --> -<p>The default name of the output image is <i>fax.tif</i>; -this can be changed with the <b>−o</b> option. Each -input file is assumed to be a separate page of facsimile -data from the same document. The order in which input files -are specified on the command line is the order in which the -resultant pages appear in the output file.</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Options that affect the interpretation of input data -are:</p> -</td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−3</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Assume input data is <small>CCITT</small> Group 3 -encoded (default).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−4</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Assume input data is <small>CCITT</small> Group 4 -encoded.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−U</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Assume input data is uncompressed (Group 3 or Group -4).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−1</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Assume input data is encoded with the 1-dimensional -version of the <small>CCITT</small> Group 3 Huffman encoding -algorithm (default).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−2</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Assume input data is 2-dimensional version of the -<small>CCITT</small> Group 3 Huffman encoding algorithm.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−P</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Assume input data is <b>not</b> EOL-aligned (default). -This option has effect with Group 3 encoded input only.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−A</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Assume input data is EOL-aligned. This option has effect -with Group 3 encoded input only.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−M</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Treat input data as having bits filled from most -significant bit ( <small>MSB</small> ) to most least bit ( -<small>LSB</small> ).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−L</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Treat input data as having bits filled from least -significant bit ( <small>LSB</small> ) to most significant -bit ( <small>MSB</small> ) (default).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−B</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Assume input data was encoded with black as 0 and white -as 1.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−W</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Assume input data was encoded with black as 1 and white -as 0 (default).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−R</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the vertical resolution, in lines/inch, of the -input images. By default input are assumed to have a -vertical resolution of 196 lines/inch. If images are low -resolution facsimile, a value of 98 lines/inch should be -specified.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−X</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the width, in pixels, of the input images. By -default input are assumed to have a width of 1728 -pixels.</p> -</td> -<td width="0%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Options that affect the output file format are:</p> -</td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−o</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the name of the output file.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−7</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force output to be compressed with the -<small>CCITT</small> Group 3 Huffman encoding algorithm -(default).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−8</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force output to be compressed with the -<small>CCITT</small> Group 4 Huffman encoding.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−u</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force output to be uncompressed (Group 3 or Group -4).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−5</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force output to be encoded with the 1-dimensional -version of the <small>CCITT</small> Group 3 Huffman encoding -algorithm.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−6</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force output to be encoded with the 2-dimensional -version of the <small>CCITT</small> Group 3 Huffman encoding -algorithm (default).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−a</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force the last bit of each <i>End Of Line</i> ( -<small>EOL</small> ) code to land on a byte boundary -(default). This ‘‘zero padding’’ -will be reflected in the contents of the -<i>Group3Options</i> tag of the resultant -<small>TIFF</small> file. This option has effect with Group -3 encoded output only.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−p</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Do not EOL-align output. This option has effect with -Group 3 encoded output only.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−c</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Generate "classic" Group 3 TIFF format.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−f</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Generate TIFF Class F (TIFF/F) format (default).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−m</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force output data to have bits filled from most -significant bit ( <small>MSB</small> ) to most least bit ( -<small>LSB</small> ).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−l</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force output data to have bits filled from least -significant bit ( <small>LSB</small> ) to most significant -bit ( <small>MSB</small> ) (default).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−r</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the number of rows (scanlines) in each strip of -data written to the output file. By default (or when value -<b>0</b> is specified), <i>tiffcp</i> attempts to set the -rows/strip that no more than 8 kilobytes of data appear in a -strip (with except of G3/G4 compression schemes). If you -specify special value <b>−1</b> it will results in -infinite number of the rows per strip. The entire image will -be the one strip in that case. This is default in case of -G3/G4 output compression schemes.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−s</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Stretch the input image vertically by writing each input -row of data twice to the output file.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−v</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force <i>fax2tiff</i> to print the number of rows of -data it retrieved from the input file.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−z</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force output to be compressed with the LZW encoding.</p> -</td> -<td width="0%"> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The following warnings and errors come from the decoding -routines in the library.</p> -<!-- INDENTATION --> -<p><b>Warning, %s: Premature EOL at scanline %d (x -%d).\n</b>. The input data had a row that was shorter than -the expected width. The row is padded with white.</p> -<!-- INDENTATION --> -<p><b>%s: Premature EOF at scanline %d (x %d).\n</b>. The -decoder ran out of data in the middle of a scanline. The -resultant row is padded with white.</p> -<!-- INDENTATION --> -<p><b>%s: Bad code word at row %d, x %d\n</b>. An invalid -Group 3 <i>code</i> was encountered while decoding the input -file. The row number and horizontal position is given. The -remainder of the input row is discarded, while the -corresponding output row is padded with white.</p> -<!-- INDENTATION --> -<p><b>%s: Bad 2D code word at scanline %d.\n</b>. An invalid -Group 4 or 2D Group 3 <i>code</i> was encountered while -decoding the input file. The row number and horizontal -position is given. The remainder of the input row is -discarded, while the corresponding output row is padded with -white.</p> -</td> -</table> -<a name="BUGS"></a> -<h2>BUGS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Input data are assumed to have a a ‘‘top -left’’ orientation; it should be possible to -override this assumption from the command line.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b><small>CCITT</small> Recommendation T.4</b> -(Standardization of Group 3 Facsimile Apparatus for Document -Transmission).</p> -<!-- INDENTATION --> -<p><b>The Spirit of TIFF Class F</b>, an appendix to the -TIFF 5.0 specification prepared by Cygnet Technologies.</p> -<!-- INDENTATION --> -<p><b>tiffinfo</b>(1), <b>tiffdither</b>(1), -<b>tiffgt</b>(1), <b>libtiff</b>(3)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/gif2tiff.1.html b/src/3rdparty/libtiff/html/man/gif2tiff.1.html deleted file mode 100644 index 6114bd3..0000000 --- a/src/3rdparty/libtiff/html/man/gif2tiff.1.html +++ /dev/null @@ -1,141 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:18 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>GIF2TIFF</title> -</head> -<body> - -<h1 align=center>GIF2TIFF</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#NOTES">NOTES</a><br> -<a href="#BUGS">BUGS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>gif2tiff − create a <small>TIFF</small> file from a -GIF87 format image file</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>gif2tiff</b> [ <i>options</i> ] <i>input.gif -output.tif</i></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>Gif2tiff</i> converts a file in the GIF87 format to -<small>TIFF.</small> The <small>TIFF</small> image is -created as a palette image, with samples compressed with the -Lempel-Ziv & Welch algorithm (<i>Compression</i>=5). -These characteristics can overridden, or explicitly -specified with the options described below.</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−c</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify a compression scheme to use when writing image -data: <b>−c none</b> for no compression, <b>−c -packbits</b> for the PackBits compression algorithm, -<b>−c zip</b> for the Deflate compression algorithm, -and <b>−c lzw</b> for Lempel-Ziv & Welch (the -default).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−r</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Write data with a specified number of rows per strip; by -default the number of rows/strip is selected so that each -strip is approximately 8 kilobytes.</p> -</td> -<td width="0%"> -</td> -</table> -<a name="NOTES"></a> -<h2>NOTES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The program is based on Paul Haeberli’s -<i>fromgif</i> program which, in turn, is based on Marcel -J.E. Mol’s GIF reader.</p> -</td> -</table> -<a name="BUGS"></a> -<h2>BUGS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Should have more options to control output format.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>pal2rgb</b>(1), <b>tiffinfo</b>(1), <b>tiffcp</b>(1), -<b>tiffmedian</b>(1), <b>libtiff</b>(3)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/index.html b/src/3rdparty/libtiff/html/man/index.html deleted file mode 100644 index 7e9e8d2..0000000 --- a/src/3rdparty/libtiff/html/man/index.html +++ /dev/null @@ -1,64 +0,0 @@ -<HTML><HEAD><TITLE>Libtiff HTML manpage index</TITLE></HEAD><BODY BGCOLOR=white><ul><H2>Man Pages</h2><p> -<li><A HREF=TIFFbuffer.3tiff.html>TIFFbuffer.3tiff.html</a> -<li><A HREF=TIFFClose.3tiff.html>TIFFClose.3tiff.html</a> -<li><A HREF=TIFFcodec.3tiff.html>TIFFcodec.3tiff.html</a> -<li><A HREF=TIFFcolor.3tiff.html>TIFFcolor.3tiff.html</a> -<li><A HREF=TIFFDataWidth.3tiff.html>TIFFDataWidth.3tiff.html</a> -<li><A HREF=TIFFError.3tiff.html>TIFFError.3tiff.html</a> -<li><A HREF=TIFFFlush.3tiff.html>TIFFFlush.3tiff.html</a> -<li><A HREF=TIFFGetField.3tiff.html>TIFFGetField.3tiff.html</a> -<li><A HREF=TIFFmemory.3tiff.html>TIFFmemory.3tiff.html</a> -<li><A HREF=TIFFOpen.3tiff.html>TIFFOpen.3tiff.html</a> -<li><A HREF=TIFFPrintDirectory.3tiff.html>TIFFPrintDirectory.3tiff.html</a> -<li><A HREF=TIFFquery.3tiff.html>TIFFquery.3tiff.html</a> -<li><A HREF=TIFFReadDirectory.3tiff.html>TIFFReadDirectory.3tiff.html</a> -<li><A HREF=TIFFReadEncodedStrip.3tiff.html>TIFFReadEncodedStrip.3tiff.html</a> -<li><A HREF=TIFFReadEncodedTile.3tiff.html>TIFFReadEncodedTile.3tiff.html</a> -<li><A HREF=TIFFReadRawStrip.3tiff.html>TIFFReadRawStrip.3tiff.html</a> -<li><A HREF=TIFFReadRawTile.3tiff.html>TIFFReadRawTile.3tiff.html</a> -<li><A HREF=TIFFReadRGBAImage.3tiff.html>TIFFReadRGBAImage.3tiff.html</a> -<li><A HREF=TIFFReadRGBAStrip.3tiff.html>TIFFReadRGBAStrip.3tiff.html</a> -<li><A HREF=TIFFReadRGBATile.3tiff.html>TIFFReadRGBATile.3tiff.html</a> -<li><A HREF=TIFFReadScanline.3tiff.html>TIFFReadScanline.3tiff.html</a> -<li><A HREF=TIFFReadTile.3tiff.html>TIFFReadTile.3tiff.html</a> -<li><A HREF=TIFFRGBAImage.3tiff.html>TIFFRGBAImage.3tiff.html</a> -<li><A HREF=TIFFSetDirectory.3tiff.html>TIFFSetDirectory.3tiff.html</a> -<li><A HREF=TIFFSetField.3tiff.html>TIFFSetField.3tiff.html</a> -<li><A HREF=TIFFsize.3tiff.html>TIFFsize.3tiff.html</a> -<li><A HREF=TIFFstrip.3tiff.html>TIFFstrip.3tiff.html</a> -<li><A HREF=TIFFswab.3tiff.html>TIFFswab.3tiff.html</a> -<li><A HREF=TIFFtile.3tiff.html>TIFFtile.3tiff.html</a> -<li><A HREF=TIFFWarning.3tiff.html>TIFFWarning.3tiff.html</a> -<li><A HREF=TIFFWriteDirectory.3tiff.html>TIFFWriteDirectory.3tiff.html</a> -<li><A HREF=TIFFWriteEncodedStrip.3tiff.html>TIFFWriteEncodedStrip.3tiff.html</a> -<li><A HREF=TIFFWriteEncodedTile.3tiff.html>TIFFWriteEncodedTile.3tiff.html</a> -<li><A HREF=TIFFWriteRawStrip.3tiff.html>TIFFWriteRawStrip.3tiff.html</a> -<li><A HREF=TIFFWriteRawTile.3tiff.html>TIFFWriteRawTile.3tiff.html</a> -<li><A HREF=TIFFWriteScanline.3tiff.html>TIFFWriteScanline.3tiff.html</a> -<li><A HREF=TIFFWriteTile.3tiff.html>TIFFWriteTile.3tiff.html</a> -<li><A HREF=fax2ps.1.html>fax2ps.1.html</a> -<li><A HREF=fax2tiff.1.html>fax2tiff.1.html</a> -<li><A HREF=gif2tiff.1.html>gif2tiff.1.html</a> -<li><A HREF=pal2rgb.1.html>pal2rgb.1.html</a> -<li><A HREF=ppm2tiff.1.html>ppm2tiff.1.html</a> -<li><A HREF=ras2tiff.1.html>ras2tiff.1.html</a> -<li><A HREF=raw2tiff.1.html>raw2tiff.1.html</a> -<li><A HREF=rgb2ycbcr.1.html>rgb2ycbcr.1.html</a> -<li><A HREF=sgi2tiff.1.html>sgi2tiff.1.html</a> -<li><A HREF=thumbnail.1.html>thumbnail.1.html</a> -<li><A HREF=tiff2bw.1.html>tiff2bw.1.html</a> -<li><A HREF=tiff2pdf.1.html>tiff2pdf.1.html</a> -<li><A HREF=tiff2ps.1.html>tiff2ps.1.html</a> -<li><A HREF=tiff2rgba.1.html>tiff2rgba.1.html</a> -<li><A HREF=tiffcmp.1.html>tiffcmp.1.html</a> -<li><A HREF=tiffcp.1.html>tiffcp.1.html</a> -<li><A HREF=tiffcrop.1.html>tiffcrop.1.html</a> -<li><A HREF=tiffdither.1.html>tiffdither.1.html</a> -<li><A HREF=tiffdump.1.html>tiffdump.1.html</a> -<li><A HREF=tiffgt.1.html>tiffgt.1.html</a> -<li><A HREF=tiffinfo.1.html>tiffinfo.1.html</a> -<li><A HREF=tiffmedian.1.html>tiffmedian.1.html</a> -<li><A HREF=tiffset.1.html>tiffset.1.html</a> -<li><A HREF=tiffsplit.1.html>tiffsplit.1.html</a> -<li><A HREF=tiffsv.1.html>tiffsv.1.html</a> -</ul></BODY></HTML> diff --git a/src/3rdparty/libtiff/html/man/libtiff.3tiff.html b/src/3rdparty/libtiff/html/man/libtiff.3tiff.html deleted file mode 100644 index bea73f7..0000000 --- a/src/3rdparty/libtiff/html/man/libtiff.3tiff.html +++ /dev/null @@ -1,3137 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:14 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>INTRO</title> -</head> -<body> - -<h1 align=center>INTRO</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#DATA TYPES">DATA TYPES</a><br> -<a href="#LIST OF ROUTINES">LIST OF ROUTINES</a><br> -<a href="#TAG USAGE">TAG USAGE</a><br> -<a href="#PSEUDO TAGS">PSEUDO TAGS</a><br> -<a href="#DIAGNOSTICS">DIAGNOSTICS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> -<a href="#BUGS">BUGS</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>libtiff − introduction to <i>libtiff</i>, a -library for reading and writing</big> TIFF -<big>files</big></p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big><b>#include <tiffio.h></b></big></p> -<!-- INDENTATION --> -<p><big>cc file.c <b>-ltiff</b></big></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big><i>libtiff</i> is a library for reading and writing -data files encoded with the <i>Tag Image File</i> format, -Revision 6.0 (or revision 5.0 or revision 4.0). This file -format is suitable for archiving multi-color and -monochromatic image data.</big></p> -<!-- INDENTATION --> -<p><big>The library supports several compression algorithms, -as indicated by the <i>Compression</i> field, including: no -compression (1),</big> CCITT <big>1D Huffman compression -(2),</big> CCITT <big>Group 3 Facsimile compression -(3),</big> CCITT <big>Group 4 Facsimile compression (4), -Lempel-Ziv & Welch compression (5), baseline JPEG -compression (7), word-aligned 1D Huffman compression -(32771), and PackBits compression (32773). In addition, -several nonstandard compression algorithms are supported: -the 4-bit compression algorithm used by the -<i>ThunderScan</i> program (32809) (decompression only), -NeXT’s 2-bit compression algorithm (32766) -(decompression only), an experimental LZ-style algorithm -known as Deflate (32946), and an experimental CIE LogLuv -compression scheme designed for images with high dynamic -range (32845 for LogL and 32845 for LogLuv). Directory -information may be in either little- or big-endian byte -order−byte swapping is automatically done by the -library. Data bit ordering may be either Most Significant -Bit (</big> MSB <big>) to Least Significant Bit (</big> LSB -<big>) or</big> LSB <big>to</big> MSB. <big>Finally, the -library does not support files in which the -<i>BitsPerSample</i>, <i>Compression</i>, -<i>MinSampleValue</i>, or <i>MaxSampleValue</i> fields are -defined differently on a per-sample basis (in Rev. 6.0 the -<i>Compression</i> tag is not defined on a per-sample basis, -so this is immaterial).</big></p> -</td> -</table> -<a name="DATA TYPES"></a> -<h2>DATA TYPES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>The library makes extensive use of C typedefs to -promote portability. Two sets of typedefs are used, one for -communication with clients of the library and one for -internal data structures and parsing of the</big> TIFF -<big>format. The following typedefs are exposed to users -either through function definitions or through parameters -passed through the varargs interfaces.</big></p></td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="3" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="15%"></td> -<td width="46%"> - -<p><big>typedef unsigned short uint16;</big></p> -</td> -<td width="38%"> - -<p><big>16-bit unsigned integer</big></p> -</td> -<tr valign="top" align="left"> -<td width="15%"></td> -<td width="46%"> - -<p><big>typedef unsigned <<i>thing</i>> -uint32;</big></p> -</td> -<td width="38%"> - -<p><big>32-bit unsigned integer</big></p> -</td> -<tr valign="top" align="left"> -<td width="15%"></td> -<td width="46%"> - -<p><big>typedef unsigned int ttag_t;</big></p> -</td> -<td width="38%"> - -<p><big>directory tag</big></p> -</td> -<tr valign="top" align="left"> -<td width="15%"></td> -<td width="46%"> - -<p><big>typedef uint16 tdir_t;</big></p> -</td> -<td width="38%"> - -<p><big>directory index</big></p> -</td> -<tr valign="top" align="left"> -<td width="15%"></td> -<td width="46%"> - -<p><big>typedef uint16 tsample_t;</big></p> -</td> -<td width="38%"> - -<p><big>sample number</big></p> -</td> -<tr valign="top" align="left"> -<td width="15%"></td> -<td width="46%"> - -<p><big>typedef uint32 tstrip_t;</big></p> -</td> -<td width="38%"> - -<p><big>strip number</big></p> -</td> -<tr valign="top" align="left"> -<td width="15%"></td> -<td width="46%"> - -<p><big>typedef uint32 ttile_t;</big></p> -</td> -<td width="38%"> - -<p><big>tile number</big></p> -</td> -<tr valign="top" align="left"> -<td width="15%"></td> -<td width="46%"> - -<p><big>typedef int32 tsize_t;</big></p> -</td> -<td width="38%"> - -<p><big>i/o size in bytes</big></p> -</td> -<tr valign="top" align="left"> -<td width="15%"></td> -<td width="46%"> - -<p><big>typedef void* tdata_t;</big></p> -</td> -<td width="38%"> - -<p><big>image data ref</big></p> -</td> -<tr valign="top" align="left"> -<td width="15%"></td> -<td width="46%"> - -<p><big>typedef void* thandle_t;</big></p> -</td> -<td width="38%"> - -<p><big>client data handle</big></p> -</td> -<tr valign="top" align="left"> -<td width="15%"></td> -<td width="46%"> - -<p><big>typedef int32 toff_t;</big></p> -</td> -<td width="38%"> - -<p><big>file offset</big></p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>Note that <i>tstrip_t</i>, <i>ttile_t</i>, and -<i>tsize_t</i> are constrained to be no more than 32-bit -quantities by 32-bit fields they are stored in in the</big> -TIFF <big>image. Likewise <i>tsample_t</i> is limited by the -16-bit field used to store the <i>SamplesPerPixel</i> tag. -<i>tdir_t</i> constrains the maximum number of</big> IFDs -<big>that may appear in an image and may be an arbitrary -size (w/o penalty). <i>ttag_t</i> must be either int, -unsigned int, pointer, or double because the library uses a -varargs interface and</big> ANSI C <big>restricts the type -of the parameter before an ellipsis to be a promoted type. -<i>toff_t</i> is defined as int32 because TIFF file offsets -are (unsigned) 32-bit quantities. A signed value is used -because some interfaces return −1 on error. Finally, -note that user-specified data references are passed as -opaque handles and only cast at the lowest layers where -their type is presumed.</big></p> -</td> -</table> -<a name="LIST OF ROUTINES"></a> -<h2>LIST OF ROUTINES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>The following routines are part of the library. -Consult specific manual pages for details on their -operation; on most systems doing ‘‘man -function-name’’ will work.</big></p></td> -</table> -<!-- TABS --> - -<p><big><i>Name Description</i></big></p> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="3" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFCheckpointDirectory</big></p> -</td> -<td width="67%"> - -<p><big>writes the current state of the directory</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFCheckTile</big></p> -</td> -<td width="67%"> - -<p><big>very x,y,z,sample is within image</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFCIELabToRGBInit</big></p> -</td> -<td width="67%"> - -<p><big>initialize CIE L*a*b* 1976 to RGB conversion -state</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFCIELabToXYZ</big></p> -</td> -<td width="67%"> - -<p><big>perform CIE L*a*b* 1976 to CIE XYZ -conversion</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFClientOpen</big></p> -</td> -<td width="67%"> - -<p><big>open a file for reading or writing</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFClose</big></p> -</td> -<td width="67%"> - -<p><big>close an open file</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFComputeStrip</big></p> -</td> -<td width="67%"> - -<p><big>return strip containing y,sample</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFComputeTile</big></p> -</td> -<td width="67%"> - -<p><big>return tile containing x,y,z,sample</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFCurrentDirectory</big></p> -</td> -<td width="67%"> - -<p><big>return index of current directory</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFCurrentRow</big></p> -</td> -<td width="67%"> - -<p><big>return index of current scanline</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFCurrentStrip</big></p> -</td> -<td width="67%"> - -<p><big>return index of current strip</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFCurrentTile</big></p> -</td> -<td width="67%"> - -<p><big>return index of current tile</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFDataWidth</big></p> -</td> -<td width="67%"> - -<p><big>return the size of TIFF data types</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFError</big></p> -</td> -<td width="67%"> - -<p><big>library error handler</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFFdOpen</big></p> -</td> -<td width="67%"> - -<p><big>open a file for reading or writing</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFFileName</big></p> -</td> -<td width="67%"> - -<p><big>return name of open file</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFFileno</big></p> -</td> -<td width="67%"> - -<p><big>return open file descriptor</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFFindCODEC</big></p> -</td> -<td width="67%"> - -<p><big>find standard codec for the specific -scheme</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFFlush</big></p> -</td> -<td width="67%"> - -<p><big>flush all pending writes</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFFlushData</big></p> -</td> -<td width="67%"> - -<p><big>flush pending data writes</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFGetBitRevTable</big></p> -</td> -<td width="67%"> - -<p><big>return bit reversal table</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFGetField</big></p> -</td> -<td width="67%"> - -<p><big>return tag value in current directory</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFGetFieldDefaulted</big></p> -</td> -<td width="67%"> - -<p><big>return tag value in current directory</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFGetMode</big></p> -</td> -<td width="67%"> - -<p><big>return open file mode</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFGetVersion</big></p> -</td> -<td width="67%"> - -<p><big>return library version string</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFIsCODECConfigured</big></p> -</td> -<td width="67%"> - -<p><big>check, whether we have working codec</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFIsMSB2LSB</big></p> -</td> -<td width="67%"> - -<p><big>return true if image data is being -returned</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"></td> -<td width="67%"> - -<p><big>with bit 0 as the most significant bit</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFIsTiled</big></p> -</td> -<td width="67%"> - -<p><big>return true if image data is tiled</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFIsByteSwapped</big></p> -</td> -<td width="67%"> - -<p><big>return true if image data is byte-swapped</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFNumberOfStrips</big></p> -</td> -<td width="67%"> - -<p><big>return number of strips in an image</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFNumberOfTiles</big></p> -</td> -<td width="67%"> - -<p><big>return number of tiles in an image</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFOpen</big></p> -</td> -<td width="67%"> - -<p><big>open a file for reading or writing</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFPrintDirectory</big></p> -</td> -<td width="67%"> - -<p><big>print description of the current -directory</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFReadBufferSetup</big></p> -</td> -<td width="67%"> - -<p><big>specify i/o buffer for reading</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFReadDirectory</big></p> -</td> -<td width="67%"> - -<p><big>read the next directory</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFReadEncodedStrip</big></p> -</td> -<td width="67%"> - -<p><big>read and decode a strip of data</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFReadEncodedTile</big></p> -</td> -<td width="67%"> - -<p><big>read and decode a tile of data</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFReadRawStrip</big></p> -</td> -<td width="67%"> - -<p><big>read a raw strip of data</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFReadRawTile</big></p> -</td> -<td width="67%"> - -<p><big>read a raw tile of data</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFReadRGBAImage</big></p> -</td> -<td width="67%"> - -<p><big>read an image into a fixed format raster</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFReadScanline</big></p> -</td> -<td width="67%"> - -<p><big>read and decode a row of data</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFReadTile</big></p> -</td> -<td width="67%"> - -<p><big>read and decode a tile of data</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFRegisterCODEC</big></p> -</td> -<td width="67%"> - -<p><big>override standard codec for the specific -scheme</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFReverseBits</big></p> -</td> -<td width="67%"> - -<p><big>reverse bits in an array of bytes</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFRGBAImageBegin</big></p> -</td> -<td width="67%"> - -<p><big>setup decoder state for TIFFRGBAImageGet</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFRGBAImageEnd</big></p> -</td> -<td width="67%"> - -<p><big>release TIFFRGBAImage decoder state</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFRGBAImageGet</big></p> -</td> -<td width="67%"> - -<p><big>read and decode an image</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFRGBAImageOK</big></p> -</td> -<td width="67%"> - -<p><big>is image readable by TIFFRGBAImageGet</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFScanlineSize</big></p> -</td> -<td width="67%"> - -<p><big>return size of a scanline</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFSetDirectory</big></p> -</td> -<td width="67%"> - -<p><big>set the current directory</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFSetSubDirectory</big></p> -</td> -<td width="67%"> - -<p><big>set the current directory</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFSetErrorHandler</big></p> -</td> -<td width="67%"> - -<p><big>set error handler function</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFSetField</big></p> -</td> -<td width="67%"> - -<p><big>set a tag’s value in the current -directory</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFSetWarningHandler</big></p> -</td> -<td width="67%"> - -<p><big>set warning handler function</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFStripSize</big></p> -</td> -<td width="67%"> - -<p><big>returns size of a strip</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFRawStripSize</big></p> -</td> -<td width="67%"> - -<p><big>returns the number of bytes in a raw -strip</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFSwabShort</big></p> -</td> -<td width="67%"> - -<p><big>swap bytes of short</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFSwabLong</big></p> -</td> -<td width="67%"> - -<p><big>swap bytes of long</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFSwabArrayOfShort</big></p> -</td> -<td width="67%"> - -<p><big>swap bytes of an array of shorts</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFSwabArrayOfLong</big></p> -</td> -<td width="67%"> - -<p><big>swap bytes of an array of longs</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFTileRowSize</big></p> -</td> -<td width="67%"> - -<p><big>return size of a row in a tile</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFTileSize</big></p> -</td> -<td width="67%"> - -<p><big>return size of a tile</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFUnRegisterCODEC</big></p> -</td> -<td width="67%"> - -<p><big>unregisters the codec</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFVGetField</big></p> -</td> -<td width="67%"> - -<p><big>return tag value in current directory</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFVGetFieldDefaulted</big></p> -</td> -<td width="67%"> - -<p><big>return tag value in current directory</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFVSetField</big></p> -</td> -<td width="67%"> - -<p><big>set a tag’s value in the current -directory</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFVStripSize</big></p> -</td> -<td width="67%"> - -<p><big>returns the number of bytes in a strip</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFWarning</big></p> -</td> -<td width="67%"> - -<p><big>library warning handler</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFWriteDirectory</big></p> -</td> -<td width="67%"> - -<p><big>write the current directory</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFWriteEncodedStrip</big></p> -</td> -<td width="67%"> - -<p><big>compress and write a strip of data</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFWriteEncodedTile</big></p> -</td> -<td width="67%"> - -<p><big>compress and write a tile of data</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFWriteRawStrip</big></p> -</td> -<td width="67%"> - -<p><big>write a raw strip of data</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFWriteRawTile</big></p> -</td> -<td width="67%"> - -<p><big>write a raw tile of data</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFWriteScanline</big></p> -</td> -<td width="67%"> - -<p><big>write a scanline of data</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFWriteTile</big></p> -</td> -<td width="67%"> - -<p><big>compress and write a tile of data</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFXYZToRGB</big></p> -</td> -<td width="67%"> - -<p><big>perform CIE XYZ to RGB conversion</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFYCbCrToRGBInit</big></p> -</td> -<td width="67%"> - -<p><big>initialize YCbCr to RGB conversion state</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>TIFFYCbCrtoRGB</big></p> -</td> -<td width="67%"> - -<p><big>perform YCbCr to RGB conversion</big></p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>Auxiliary functions:</big></p></td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="3" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>_TIFFfree</big></p> -</td> -<td width="67%"> - -<p><big>free memory buffer</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>_TIFFmalloc</big></p> -</td> -<td width="67%"> - -<p><big>dynamically allocate memory buffer</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>_TIFFmemcmp</big></p> -</td> -<td width="67%"> - -<p><big>compare contents of the memory buffers</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>_TIFFmemcpy</big></p> -</td> -<td width="67%"> - -<p><big>copy contents of the one buffer to -another</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>_TIFFmemset</big></p> -</td> -<td width="67%"> - -<p><big>fill memory buffer with a constant byte</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="23%"> - -<p><big>_TIFFrealloc</big></p> -</td> -<td width="67%"> - -<p><big>dynamically reallocate memory buffer</big></p> -</td> -</table> -<a name="TAG USAGE"></a> -<h2>TAG USAGE</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>The table below lists the</big> TIFF <big>tags that -are recognized and handled by the library. If no use is -indicated in the table, then the library reads and writes -the tag, but does not use it internally. Note that some tags -are meaningful only when a particular compression scheme is -being used; e.g. <i>Group3Options</i> is only useful if -<i>Compression</i> is set to</big> CCITT <big>Group 3 -encoding. Tags of this sort are considered -<i>codec-specific</i> tags and the library does not -recognize them except when the <i>Compression</i> tag has -been previously set to the relevant compression -scheme.</big></p> -<!-- INDENTATION --> -<pre><big><i>Tag Name Value R/W Library Use/Notes -</i></big></pre> -</td> -</table> -<!-- TABS --> - -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>Artist</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>315</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>BadFaxLines</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>326</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>BitsPerSample</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>258</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>lots</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>CellLength</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>265</big></p> -</td> -<td width="53%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>parsed but ignored</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>CellWidth</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>264</big></p> -</td> -<td width="53%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>parsed but ignored</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>CleanFaxData</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>327</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>ColorMap</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>320</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>ColorResponseUnit</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>300</big></p> -</td> -<td width="53%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>parsed but ignored</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>Compression</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>259</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>choosing codec</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>ConsecutiveBadFaxLines</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>328</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>Copyright 33432 R/W</big></p></td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>DataType</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>32996</big></p> -</td> -<td width="53%"> - -<p><big>R</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>obsoleted by SampleFormat tag</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>DateTime</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>306</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>DocumentName</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>269</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>DotRange</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>336</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>ExtraSamples</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>338</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>lots</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>FaxRecvParams</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>34908</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>FaxSubAddress</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>34909</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>FaxRecvTime</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>34910</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>FillOrder</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>266</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>control bit order</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>FreeByteCounts</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>289</big></p> -</td> -<td width="53%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>parsed but ignored</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>FreeOffsets</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>288</big></p> -</td> -<td width="53%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>parsed but ignored</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>GrayResponseCurve</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>291</big></p> -</td> -<td width="53%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>parsed but ignored</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>GrayResponseUnit</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>290</big></p> -</td> -<td width="53%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>parsed but ignored</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>Group3Options</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>292</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>used by Group 3 codec</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>Group4Options</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>293</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>HostComputer</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>316</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>ImageDepth</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>32997</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>tile/strip calculations</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>ImageDescription</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>270</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>ImageLength</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>257</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>lots</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>ImageWidth</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>256</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>lots</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>InkNames</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>333</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>InkSet</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>332</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>JPEGTables</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>347</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>used by JPEG codec</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>Make</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>271</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>Matteing</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>32995</big></p> -</td> -<td width="53%"> - -<p><big>R</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>obsoleted by ExtraSamples tag</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>MaxSampleValue</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>281</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>MinSampleValue</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>280</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>Model</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>272</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>NewSubFileType</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>254</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>called SubFileType in spec</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>NumberOfInks</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>334</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>Orientation</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>274</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>PageName</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>285</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>PageNumber</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>297</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>PhotometricInterpretation</big></p> -</td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>262</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>R/Wused by Group 3 and JPEG codecs</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>PlanarConfiguration</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>284</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>data i/o</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>Predictor</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>317</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>used by LZW and Deflate codecs</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>PrimaryChromacities</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>319</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>ReferenceBlackWhite</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>532</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>ResolutionUnit</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>296</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>used by Group 3 codec</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>RowsPerStrip</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>278</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>data i/o</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>SampleFormat</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>339</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>SamplesPerPixel</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>277</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>lots</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>SMinSampleValue</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>340</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>SMaxSampleValue</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>341</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>Software</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>305</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>StoNits</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>37439</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>StripByteCounts</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>279</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>data i/o</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>StripOffsets</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>273</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>data i/o</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>SubFileType</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>255</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>called OSubFileType in spec</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>TargetPrinter</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>337</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>Thresholding</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>263</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>TileByteCounts</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>324</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>data i/o</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>TileDepth</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>32998</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>tile/strip calculations</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>TileLength</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>323</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>data i/o</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>TileOffsets</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>324</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>data i/o</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>TileWidth</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>322</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>data i/o</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>TransferFunction</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>301</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>WhitePoint</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>318</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>XPosition</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>286</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>XResolution</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>282</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>YCbCrCoefficients</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>529</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>used by TIFFRGBAImage support</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>YCbCrPositioning</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>531</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>tile/strip size calulcations</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>YCbCrSubsampling</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>530</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>YPosition</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>286</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>YResolution</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>283</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>used by Group 3 codec</big></p> -</td> -</table> -<a name="PSEUDO TAGS"></a> -<h2>PSEUDO TAGS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>In addition to the normal</big> TIFF <big>tags the -library supports a collection of tags whose values lie in a -range outside the valid range of</big> TIFF <big>tags. These -tags are termed <i>pseud-tags</i> and are used to control -various codec-specific functions within the library. The -table below summarizes the defined pseudo-tags.</big></p> -<!-- INDENTATION --> -<pre><big><i>Tag Name Codec R/W Library Use/Notes -</i></big></pre> -</td> -</table> -<!-- TABS --> - -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>TIFFTAG_FAXMODE</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>G3</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>general codec operation</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>TIFFTAG_FAXFILLFUNC</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>G3/G4</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>bitmap fill function</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>TIFFTAG_JPEGQUALITY</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>JPEG</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>compression quality control</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>TIFFTAG_JPEGCOLORMODE</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>JPEG</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>control colorspace conversions</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>TIFFTAG_JPEGTABLESMODE</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>JPEG</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>control contents of <i>JPEGTables</i> tag</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>TIFFTAG_ZIPQUALITY</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>Deflate</big></p> -</td> -<td width="53%"> - -<p><big>R/Wcompression quality level</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>TIFFTAG_PIXARLOGDATAFMT</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>PixarLog</big></p> -</td> -<td width="53%"> - -<p><big>R/Wuser data format</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>TIFFTAG_PIXARLOGQUALITY</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>PixarLog</big></p> -</td> -<td width="53%"> - -<p><big>R/Wcompression quality level</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"> - -<p><big>TIFFTAG_SGILOGDATAFMT</big></p> -</td> -<td width="8%"></td> -<td width="6%"> - -<p><big>SGILog</big></p> -</td> -<td width="53%"> - -<p><big>R/W</big></p> -</td> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="21%"></td> -<td width="8%"></td> -<td width="6%"></td> -<td width="53%"> - -<p><big>user data format</big></p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big><b>TIFFTAG_FAXMODE</b></big></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p><big>Control the operation of the Group 3 codec. Possible -values (independent bits that can be combined by -or’ing them together) are: FAXMODE_CLASSIC (enable -old-style format in which the</big> RTC <big>is written at -the end of the last strip), FAXMODE_NORTC (opposite of -FAXMODE_CLASSIC; also called FAXMODE_CLASSF), FAXMODE_NOEOL -(do not write</big> EOL <big>codes at the start of each row -of data), FAXMODE_BYTEALIGN (align each encoded row to an -8-bit boundary), FAXMODE_WORDALIGN (align each encoded row -to an 16-bit boundary), The default value is dependent on -the compression scheme; this pseudo-tag is used by the -various G3 and G4 codecs to share code.</big></p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big><b>TIFFTAG_FAXFILLFUNC</b></big></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p><big>Control the function used to convert arrays of black -and white runs to packed bit arrays. This hook can be used -to image decoded scanlines in multi-bit depth rasters (e.g. -for display in colormap mode) or for other purposes. The -default value is a pointer to a builtin function that images -packed bilevel data.</big></p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big><b>TIFFTAG_IPTCNEWSPHOTO</b></big></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p><big>Tag contaings image metadata per the IPTC newsphoto -spec: Headline, captioning, credit, etc... Used by most wire -services.</big></p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big><b>TIFFTAG_PHOTOSHOP</b></big></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p><big>Tag contains Photoshop captioning information and -metadata. Photoshop uses in parallel and redundantly -alongside IPTCNEWSPHOTO information.</big></p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big><b>TIFFTAG_JPEGQUALITY</b></big></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p><big>Control the compression quality level used in the -baseline algorithm. Note that quality levels are in the -range 0-100 with a default value of 75.</big></p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big><b>TIFFTAG_JPEGCOLORMODE</b></big></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p><big>Control whether or not conversion is done between -RGB and YCbCr colorspaces. Possible values are: -JPEGCOLORMODE_RAW (do not convert), and JPEGCOLORMODE_RGB -(convert to/from RGB) The default value is -JPEGCOLORMODE_RAW.</big></p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big><b>TIFFTAG_JPEGTABLESMODE</b></big></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p><big>Control the information written in the -<i>JPEGTables</i> tag. Possible values (independent bits -that can be combined by or’ing them together) are: -JPEGTABLESMODE_QUANT (include quantization tables), and -JPEGTABLESMODE_HUFF (include Huffman encoding tables). The -default value is -JPEGTABLESMODE_QUANT|JPEGTABLESMODE_HUFF.</big></p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big><b>TIFFTAG_ZIPQUALITY</b></big></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p><big>Control the compression technique used by the -Deflate codec. Quality levels are in the range 1-9 with -larger numbers yielding better compression at the cost of -more computation. The default quality level is 6 which -yields a good time-space tradeoff.</big></p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big><b>TIFFTAG_PIXARLOGDATAFMT</b></big></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p><big>Control the format of user data passed <i>in</i> to -the PixarLog codec when encoding and passed <i>out</i> from -when decoding. Possible values are: PIXARLOGDATAFMT_8BIT for -8-bit unsigned pixels, PIXARLOGDATAFMT_8BITABGR for 8-bit -unsigned ABGR-ordered pixels, PIXARLOGDATAFMT_11BITLOG for -11-bit log-encoded raw data, PIXARLOGDATAFMT_12BITPICIO for -12-bit PICIO-compatible data, PIXARLOGDATAFMT_16BIT for -16-bit signed samples, and PIXARLOGDATAFMT_FLOAT for 32-bit -IEEE floating point samples.</big></p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big><b>TIFFTAG_PIXARLOGQUALITY</b></big></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p><big>Control the compression technique used by the -PixarLog codec. This value is treated identically to -TIFFTAG_ZIPQUALITY; see the above description.</big></p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big><b>TIFFTAG_SGILOGDATAFMT</b></big></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p><big>Control the format of client data passed <i>in</i> -to the SGILog codec when encoding and passed <i>out</i> from -when decoding. Possible values are: SGILOGDATAFMT_FLTXYZ for -converting between LogLuv and 32-bit IEEE floating valued -XYZ pixels, SGILOGDATAFMT_16BITLUV for 16-bit encoded Luv -pixels, SGILOGDATAFMT_32BITRAW and SGILOGDATAFMT_24BITRAW -for no conversion of data, SGILOGDATAFMT_8BITRGB for -returning 8-bit RGB data (valid only when decoding -LogLuv-encoded data), SGILOGDATAFMT_FLTY for converting -between LogL and 32-bit IEEE floating valued Y pixels, -SGILOGDATAFMT_16BITL for 16-bit encoded L pixels, and -SGILOGDATAFMT_8BITGRY for returning 8-bit greyscale data -(valid only when decoding LogL-encoded data).</big></p> -</td> -</table> -<a name="DIAGNOSTICS"></a> -<h2>DIAGNOSTICS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>All error messages are directed through the -<i>TIFFError</i> routine. By default messages are directed -to <b>stderr</b> in the form: <i>module: message\n.</i> -Warning messages are likewise directed through the -<i>TIFFWarning</i> routine.</big></p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big><b>fax2tiff</b>(1), <b>gif2tiff</b>(1), -<b>pal2rgb</b>(1), <b>ppm2tiff</b>(1), <b>rgb2ycbcr</b>(1), -<b>ras2tiff</b>(1), <b>raw2tiff</b>(1), <b>sgi2tiff</b>(1), -<b>tiff2bw</b>(1), <b>tiffdither</b>(1), <b>tiffdump</b>(1), -<b>tiffcp</b>(1), <b>tiffcmp</b>(1), <b>tiffgt</b>(1), -<b>tiffinfo</b>(1), <b>tiffmedian</b>(1), -<b>tiffsplit</b>(1), <b>tiffsv</b>(1).</big></p> -<!-- INDENTATION --> -<p><big><b>Tag Image File Format Specification — -Revision 6.0</b>, an Aldus Technical Memorandum.</big></p> -<!-- INDENTATION --> -<p><big><b>The Spirit of TIFF Class F</b>, an appendix to -the TIFF 5.0 specification prepared by Cygnet -Technologies.</big></p> -<!-- INDENTATION --> -<p><big>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></big></p> -</td> -</table> -<a name="BUGS"></a> -<h2>BUGS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><big>The library does not support multi-sample images -where some samples have different bits/sample.</big></p> -<!-- INDENTATION --> -<p><big>The library does not support random access to -compressed data that is organized with more than one row per -tile or strip.</big></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/pal2rgb.1.html b/src/3rdparty/libtiff/html/man/pal2rgb.1.html deleted file mode 100644 index 5c3a679..0000000 --- a/src/3rdparty/libtiff/html/man/pal2rgb.1.html +++ /dev/null @@ -1,189 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:18 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>PAL2RGB</title> -</head> -<body> - -<h1 align=center>PAL2RGB</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#BUGS">BUGS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>pal2rgb − convert a palette color -<small>TIFF</small> image to a full color image</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>pal2rgb</b> [ <i>options</i> ] <i>input.tif -output.tif</i></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>Pal2rgb</i> converts a palette color -<small>TIFF</small> image to a full color image by applying -the colormap of the palette image to each sample to generate -a full color <small>RGB</small> image.</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Options that affect the interpretation of input data -are:</p> -</td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="11%"></td> -<td width="2%"> - -<p><b>−C</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>This option overrides the default behavior of -<i>pal2rgb</i> in determining whether or not colormap -entries contain 16-bit or 8-bit values. By default the -colormap is inspected and if no colormap entry greater than -255 is found, the colormap is assumed to have only 8-bit -values; otherwise 16-bit values (as required by the -<small>TIFF</small> specification) are assumed. The -<b>−C</b> option can be used to explicitly specify the -number of bits for colormap entries: <b>−C 8</b> for -8-bit values, <b>−C 16</b> for 16-bit values.</p> -</td> -<td width="0%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Options that affect the output file format are:</p> -</td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="5%"> - -<p><b>−p</b></p> -</td> -<td width="3%"></td> -<td width="80%"> - -<p>Explicitly select the planar configuration used in -organizing data samples in the output image: <b>−p -contig</b> for samples packed contiguously, and <b>−p -separate</b> for samples stored separately. By default -samples are packed.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="5%"> - -<p><b>−c</b></p> -</td> -<td width="3%"></td> -<td width="80%"> - -<p>Use the specific compression algorithm to encoded image -data in the output file: <b>−c packbits</b> for -Macintosh Packbits, <b>−c lzw</b> for Lempel-Ziv & -Welch, <b>−c zip</b> for Deflate, <b>−c none</b> -for no compression. If no compression-related option is -specified, the input file’s compression algorithm is -used.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="5%"> - -<p><b>−r</b></p> -</td> -<td width="3%"></td> -<td width="80%"> - -<p>Explicitly specify the number of rows in each strip of -the output file. If the <b>−r</b> option is not -specified, a number is selected such that each output strip -has approximately 8 kilobytes of data in it.</p> -</td> -<td width="0%"> -</td> -</table> -<a name="BUGS"></a> -<h2>BUGS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Only 8-bit images are handled.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiffinfo</b>(1), <b>tiffcp</b>(1), -<b>tiffmedian</b>(1), <b>libtiff</b>(3)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/ppm2tiff.1.html b/src/3rdparty/libtiff/html/man/ppm2tiff.1.html deleted file mode 100644 index 60e56e1..0000000 --- a/src/3rdparty/libtiff/html/man/ppm2tiff.1.html +++ /dev/null @@ -1,141 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:18 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>PPM2TIFF</title> -</head> -<body> - -<h1 align=center>PPM2TIFF</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>ppm2tiff − create a <small>TIFF</small> file from -<small>PPM, PGM</small> and <small>PBM</small> image -files</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>ppm2tiff</b> [ <i>options</i> ] [ <i>input.ppm</i> ] -<i>output.tif</i></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>ppm2tiff</i> converts a file in the <small>PPM, -PGM</small> and <small>PBM</small> image formats to -<small>TIFF.</small> By default, the <small>TIFF</small> -image is created with data samples packed -(<i>PlanarConfiguration</i>=1), compressed with the Packbits -algorithm (<i>Compression</i>=32773), and with each strip no -more than 8 kilobytes. These characteristics can be -overridden, or explicitly specified with the options -described below</p> -<!-- INDENTATION --> -<p>If the <small>PPM</small> file contains greyscale data, -then the <i>PhotometricInterpretation</i> tag is set to 1 -(min-is-black), otherwise it is set to 2 (RGB).</p> -<!-- INDENTATION --> -<p>If no <small>PPM</small> file is specified on the command -line, <i>ppm2tiff</i> will read from the standard input.</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−c</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify a compression scheme to use when writing image -data: <b>none</b> for no compression, <b>packbits</b> for -PackBits compression (will be used by default), <b>lzw</b> -for Lempel-Ziv & Welch compression, <b>jpeg</b> for -baseline JPEG compression, <b>zip</b> for Deflate -compression, <b>g3</b> for CCITT Group 3 (T.4) compression, -and <b>g4</b> for CCITT Group 4 (T.6) compression.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−r</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Write data with a specified number of rows per strip; by -default the number of rows/strip is selected so that each -strip is approximately 8 kilobytes.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−R</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Mark the resultant image to have the specified X and Y -resolution (in dots/inch).</p> -</td> -<td width="0%"> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiffinfo</b>(1), <b>tiffcp</b>(1), -<b>tiffmedian</b>(1), <b>libtiff</b>(3)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/ras2tiff.1.html b/src/3rdparty/libtiff/html/man/ras2tiff.1.html deleted file mode 100644 index b0b8993..0000000 --- a/src/3rdparty/libtiff/html/man/ras2tiff.1.html +++ /dev/null @@ -1,139 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:18 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>RAS2TIFF</title> -</head> -<body> - -<h1 align=center>RAS2TIFF</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#BUGS">BUGS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>ras2tiff − create a <small>TIFF</small> file from a -Sun rasterfile</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>ras2tiff</b> [ <i>options</i> ] <i>input.ras -output.tif</i></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>ras2tiff</i> converts a file in the Sun rasterfile -format to <small>TIFF.</small> By default, the -<small>TIFF</small> image is created with data samples -packed (<i>PlanarConfiguration</i>=1), compressed with the -Lempel-Ziv & Welch algorithm (<i>Compression</i>=5), and -with each strip no more than 8 kilobytes. These -characteristics can overridden, or explicitly specified with -the options described below.</p> -<!-- INDENTATION --> -<p>Any colormap information in the rasterfile is carried -over to the <small>TIFF</small> file by including a -<i>Colormap</i> tag in the output file. If the rasterfile -has a colormap, the <i>PhotometricInterpretation</i> tag is -set to 3 (palette); otherwise it is set to 2 (RGB) if the -depth is 24 or 1 (min-is-black) if the depth is not 24.</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="2%"> - -<p><b>−c</b></p> -</td> -<td width="6%"></td> -<td width="80%"> - -<p>Specify a compression scheme to use when writing image -data: <b>−c none</b> for no compression, <b>−c -packbits</b> for the PackBits compression algorithm, -<b>−c jpeg</b> for the baseline JPEG compression -algorithm, <b>−c zip</b> for the Deflate compression -algorithm, and <b>−c lzw</b> for Lempel-Ziv & -Welch (the default).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="2%"> - -<p><b>−r</b></p> -</td> -<td width="6%"></td> -<td width="80%"> - -<p>Write data with a specified number of rows per strip; by -default the number of rows/strip is selected so that each -strip is approximately 8 kilobytes.</p> -</td> -<td width="0%"> -</td> -</table> -<a name="BUGS"></a> -<h2>BUGS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Does not handle all possible rasterfiles. In particular, -<i>ras2tiff</i> does not handle run-length encoded -images.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>pal2rgb</b>(1), <b>tiffinfo</b>(1), <b>tiffcp</b>(1), -<b>tiffmedian</b>(1), <b>libtiff</b>(3)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/raw2tiff.1.html b/src/3rdparty/libtiff/html/man/raw2tiff.1.html deleted file mode 100644 index 360eb27..0000000 --- a/src/3rdparty/libtiff/html/man/raw2tiff.1.html +++ /dev/null @@ -1,510 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:18 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>RAW2TIFF</title> -</head> -<body> - -<h1 align=center>RAW2TIFF</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#GUESSING THE IMAGE GEOMETRY">GUESSING THE IMAGE GEOMETRY</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>raw2tiff − create a <small>TIFF</small> file from a -raw data</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>raw2tiff</b> [ <i>options</i> ] <i>input.raw -output.tif</i></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>raw2tiff</i> converts a raw byte sequence into -<small>TIFF.</small> By default, the <small>TIFF</small> -image is created with data samples packed -(<i>PlanarConfiguration</i>=1), compressed with the PackBits -algorithm (<i>Compression</i>=32773), and with each strip no -more than 8 kilobytes. These characteristics can overridden, -or explicitly specified with the options described -below.</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−H</b> <i>number</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>size of input image file header in bytes (0 by default). -This amount of data just will be skipped from the start of -file while reading.</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−w</b> <i>number</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>width of input image in pixels (can be guessed, see -<b><small>GUESSING THE IMAGE GEOMETRY</small></b> -below).</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−l</b> <i>number</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>length of input image in lines (can be guessed, see -<b><small>GUESSING THE IMAGE GEOMETRY</small></b> -below).</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−b</b> <i>number</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>number of bands in input image (1 by default).</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−d</b> <i>data_type</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>type of samples in input image, where <i>data_type</i> -may be:</p></td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="3" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="10%"> - -<p><b>byte</b></p> -</td> -<td width="70%"> - -<p>8-bit unsigned integer (default),</p> -</td> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="10%"> - -<p><b>short</b></p> -</td> -<td width="70%"> - -<p>16-bit unsigned integer,</p> -</td> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="10%"> - -<p><b>long</b></p> -</td> -<td width="70%"> - -<p>32-bit unsigned integer,</p> -</td> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="10%"> - -<p><b>sbyte</b></p> -</td> -<td width="70%"> - -<p>8-bit signed integer,</p> -</td> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="10%"> - -<p><b>sshort</b></p> -</td> -<td width="70%"> - -<p>16-bit signed integer,</p> -</td> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="10%"> - -<p><b>slong</b></p> -</td> -<td width="70%"> - -<p>32-bit signed integer,</p> -</td> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="10%"> - -<p><b>float</b></p> -</td> -<td width="70%"> - -<p>32-bit IEEE floating point,</p> -</td> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="10%"> - -<p><b>double</b></p> -</td> -<td width="70%"> - -<p>64-bit IEEE floating point.</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−i</b> <i>config</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>type of samples interleaving in input image, where -<i>config</i> may be:</p></td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="3" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="8%"> - -<p><b>pixel</b></p> -</td> -<td width="71%"> - -<p>pixel interleaved data (default),</p> -</td> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="8%"> - -<p><b>band</b></p> -</td> -<td width="71%"> - -<p>band interleaved data.</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−p</b> <i>photo</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>photometric interpretation (color space) of the input -image, where <i>photo</i> may be:</p></td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="3" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="15%"> - -<p><b>miniswhite</b></p> -</td> -<td width="65%"> - -<p>white color represented with 0 value,</p> -</td> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="15%"> - -<p><b>minisblack</b></p> -</td> -<td width="65%"> - -<p>black color represented with 0 value (default),</p> -</td> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="15%"> - -<p><b>rgb</b></p> -</td> -<td width="65%"> - -<p>image has RGB color model,</p> -</td> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="15%"> - -<p><b>cmyk</b></p> -</td> -<td width="65%"> - -<p>image has CMYK (separated) color model,</p> -</td> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="15%"> - -<p><b>ycbcr</b></p> -</td> -<td width="65%"> - -<p>image has YCbCr color model,</p> -</td> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="15%"> - -<p><b>cielab</b></p> -</td> -<td width="65%"> - -<p>image has CIE L*a*b color model,</p> -</td> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="15%"> - -<p><b>icclab</b></p> -</td> -<td width="65%"> - -<p>image has ICC L*a*b color model,</p> -</td> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="15%"> - -<p><b>itulab</b></p> -</td> -<td width="65%"> - -<p>image has ITU L*a*b color model.</p> -</td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−s</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>swap bytes fetched from the input file.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−L</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>input data has LSB2MSB bit order (default).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−M</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>input data has MSB2LSB bit order.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−c</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify a compression scheme to use when writing image -data: <b>−c none</b> for no compression, <b>−c -packbits</b> for the PackBits compression algorithm (the -default), <b>−c jpeg</b> for the baseline JPEG -compression algorithm, <b>−c zip</b> for the Deflate -compression algorithm, and <b>−c lzw</b> for -Lempel-Ziv & Welch.</p> -</td> -<td width="0%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−r</b> <i>number</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>Write data with a specified number of rows per strip; by -default the number of rows/strip is selected so that each -strip is approximately 8 kilobytes.</p> -</td> -</table> -<a name="GUESSING THE IMAGE GEOMETRY"></a> -<h2>GUESSING THE IMAGE GEOMETRY</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>raw2tiff</i> can guess image width and height in case -one or both of these parameters are not specified. If you -omit one of those parameters, the complementary one will be -calculated based on the file size (taking into account -header size, number of bands and data type). If you omit -both parameters, the statistical approach will be used. -Utility will compute correlation coefficient between two -lines at the image center using several appropriate line -sizes and the highest absolute value of the coefficient will -indicate the right line size. That is why you should be -cautious with the very large images, because guessing -process may take a while (depending on your system -performance). Of course, the utility can’t guess the -header size, number of bands and data type, so it should be -specified manually. If you don’t know anything about -your image, just try with the several combinations of those -options.</p> -<!-- INDENTATION --> -<p>There is no magic, it is just a mathematical statistics, -so it can be wrong in some cases. But for most ordinary -images guessing method will work fine.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>pal2rgb</b>(1), <b>tiffcp</b>(1), -<b>tiffmedian</b>(1), <b>libtiff</b>(3)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/rgb2ycbcr.1.html b/src/3rdparty/libtiff/html/man/rgb2ycbcr.1.html deleted file mode 100644 index 5cff15f..0000000 --- a/src/3rdparty/libtiff/html/man/rgb2ycbcr.1.html +++ /dev/null @@ -1,155 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:19 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>RGB2YCBCR</title> -</head> -<body> - -<h1 align=center>RGB2YCBCR</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>rgb2ycbcr − convert non-YCbCr <small>TIFF</small> -images to a YCbCr <small>TIFF</small> image</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>rgb2ycbcr</b> [ <i>options</i> ] <i>src1.tif src2.tif -... dst.tif</i></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>rgb2ycbcr</i> converts <small>RGB</small> color, -greyscale, or bi-level <small>TIFF</small> images to YCbCr -images by transforming and sampling pixel data. If multiple -files are specified on the command line each source file is -converted to a separate directory in the destination -file.</p> -<!-- INDENTATION --> -<p>By default, chrominance samples are created by sampling 2 -by 2 blocks of luminance values; this can be changed with -the <b>−h</b> and <b>−v</b> options. Output data -are compressed with the <small>PackBits</small> compression -scheme, by default; an alternate scheme can be selected with -the <b>−c</b> option. By default, output data are -compressed in strips with the number of rows in each strip -selected so that the size of a strip is never more than 8 -kilobytes; the <b>−r</b> option can be used to -explicitly set the number of rows per strip.</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−c</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify a compression scheme to use when writing image -data: <b>−c none</b> for no compression, <b>−c -packbits</b> for the PackBits compression algorithm (the -default), <b>−c jpeg</b> for the JPEG compression -algorithm, <b>−c zip</b> for the deflate compression -algorithm, and <b>−c lzw</b> for Lempel-Ziv & -Welch.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−h</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Set the horizontal sampling dimension to one of: 1, 2 -(default), or 4.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−r</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Write data with a specified number of rows per strip; by -default the number of rows/strip is selected so that each -strip is approximately 8 kilobytes.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−v</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Set the vertical sampling dimension to one of: 1, 2 -(default), or 4.</p> -</td> -<td width="0%"> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiffinfo</b>(1), <b>tiffcp</b>(1), -<b>libtiff</b>(3)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/sgi2tiff.1.html b/src/3rdparty/libtiff/html/man/sgi2tiff.1.html deleted file mode 100644 index fe90d64..0000000 --- a/src/3rdparty/libtiff/html/man/sgi2tiff.1.html +++ /dev/null @@ -1,147 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:19 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>SGI2TIFF</title> -</head> -<body> - -<h1 align=center>SGI2TIFF</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#BUGS">BUGS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>sgi2tiff − create a <small>TIFF</small> file from -an <small>SGI</small> image file</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>sgi2tiff</b> [ <i>options</i> ] <i>input.rgb -output.tif</i></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>sgi2tiff</i> converts a file in the <small>SGI</small> -image format to <small>TIFF.</small> By default, the -<small>TIFF</small> image is created with data samples -packed (<i>PlanarConfiguration</i>=1), compressed with the -Lempel-Ziv & Welch algorithm (<i>Compression</i>=5), and -with each strip no more than 8 kilobytes. These -characteristics can overridden, or explicitly specified with -the options described below.</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−c</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify a compression scheme to use when writing image -data: <b>−c none</b> for no compression, <b>−c -packbits</b> for the PackBits compression algorithm), -<b>−c jpeg</b> for the baseline JPEG compression -algorithm, <b>−c zip</b> for the Deflate compression -algorithm, and <b>−c lzw</b> for Lempel-Ziv & -Welch (the default).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−p</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Explicitly select the planar configuration used in -organizing data samples in the output image: <b>−p -contig</b> for samples packed contiguously, and <b>−p -separate</b> for samples stored separately. By default -samples are packed.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−r</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Write data with a specified number of rows per strip; by -default the number of rows/strip is selected so that each -strip is approximately 8 kilobytes.</p> -</td> -<td width="0%"> -</td> -</table> -<a name="BUGS"></a> -<h2>BUGS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Does not record colormap information.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiffinfo</b>(1), <b>tiffcp</b>(1), -<b>tiffmedian</b>(1), <b>libtiff</b>(3)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/thumbnail.1.html b/src/3rdparty/libtiff/html/man/thumbnail.1.html deleted file mode 100644 index fabc601..0000000 --- a/src/3rdparty/libtiff/html/man/thumbnail.1.html +++ /dev/null @@ -1,148 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:19 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>THUMBNAIL</title> -</head> -<body> - -<h1 align=center>THUMBNAIL</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#BUGS">BUGS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>thumbnail − create a <small>TIFF</small> file with -thumbnail images</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>thumbnail</b> [ <i>options</i> ] <i>input.tif -output.tif</i></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>thumbnail</i> is a program written to show how one -might use the SubIFD tag (#330) to store thumbnail images. -<i>thumbnail</i> copies a <small>TIFF</small> Class F -facsimile file to the output file and for each image an -8-bit greyscale <i>thumbnail sketch</i>. The output file -contains the thumbnail image with the associated -full-resolution page linked below with the SubIFD tag.</p> -<!-- INDENTATION --> -<p>By default, thumbnail images are 216 pixels wide by 274 -pixels high. Pixels are calculated by sampling and filtering -the input image with each pixel value passed through a -contrast curve.</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−w</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the width of thumbnail images in pixels.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−h</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the height of thumbnail images in pixels.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−c</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify a contrast curve to apply in generating the -thumbnail images. By default pixels values are passed -through a linear contrast curve that simply maps the pixel -value ranges. Alternative curves are: <b>exp50</b> for a 50% -exponential curve, <b>exp60</b> for a 60% exponential curve, -<b>exp70</b> for a 70% exponential curve, <b>exp80</b> for a -80% exponential curve, <b>exp90</b> for a 90% exponential -curve, <b>exp</b> for a pure exponential curve, -<b>linear</b> for a linear curve.</p> -</td> -<td width="0%"> -</td> -</table> -<a name="BUGS"></a> -<h2>BUGS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>There are no options to control the format of the saved -thumbnail images.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiffdump</b>(1), <b>tiffgt</b>(1), <b>tiffinfo</b>(1), -<b>libtiff</b>(3)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/tiff2bw.1.html b/src/3rdparty/libtiff/html/man/tiff2bw.1.html deleted file mode 100644 index 6b6accf..0000000 --- a/src/3rdparty/libtiff/html/man/tiff2bw.1.html +++ /dev/null @@ -1,161 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:19 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFF2BW</title> -</head> -<body> - -<h1 align=center>TIFF2BW</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>tiff2bw − convert a color <small>TIFF</small> image -to greyscale</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiff2bw</b> [ <i>options</i> ] <i>input.tif -output.tif</i></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>Tiff2bw</i> converts an <small>RGB</small> or Palette -color <small>TIFF</small> image to a greyscale image by -combining percentages of the red, green, and blue channels. -By default, output samples are created by taking 28% of the -red channel, 59% of the green channel, and 11% of the blue -channel. To alter these percentages, the <b>−R</b>, -<b>−G</b>, and <b>−B</b> options may be -used.</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−c</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify a compression scheme to use when writing image -data: <b>−c none</b> for no compression, <b>−c -packbits</b> for the PackBits compression algorithm, -<b>−c zip</b> for the Deflate compression algorithm, -<b>−c g3</b> for the CCITT Group 3 compression -algorithm, <b>−c g4</b> for the CCITT Group 4 -compression algorithm, and <b>−c lzw</b> for -Lempel-Ziv & Welch (the default).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−r</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Write data with a specified number of rows per strip; by -default the number of rows/strip is selected so that each -strip is approximately 8 kilobytes.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−R</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the percentage of the red channel to use -(default 28).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−G</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the percentage of the green channel to use -(default 59).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−B</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the percentage of the blue channel to use -(default 11).</p> -</td> -<td width="0%"> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>pal2rgb</b>(1), <b>tiffinfo</b>(1), <b>tiffcp</b>(1), -<b>tiffmedian</b>(1), <b>libtiff</b>(3)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/tiff2pdf.1.html b/src/3rdparty/libtiff/html/man/tiff2pdf.1.html deleted file mode 100644 index 80e0d55..0000000 --- a/src/3rdparty/libtiff/html/man/tiff2pdf.1.html +++ /dev/null @@ -1,609 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:19 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFF2PDF</title> -</head> -<body> - -<h1 align=center>TIFF2PDF</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#EXAMPLES">EXAMPLES</a><br> -<a href="#BUGS">BUGS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="89%"> -<p>tiff2pdf − convert a TIFF image to a PDF -document</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="89%"> -<p><b>tiff2pdf</b> [ <i>options</i> ] <i>input.tiff</i></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="89%"> -<p><i>tiff2pdf</i> opens a TIFF image and writes a PDF -document to standard output.</p> -<!-- INDENTATION --> -<p>The program converts one TIFF file to one PDF file, -including multiple page TIFF files, tiled TIFF files, black -and white. grayscale, and color TIFF files that contain data -of TIFF photometric interpretations of bilevel, grayscale, -RGB, YCbCr, CMYK separation, and ICC L*a*b* as supported by -<i>libtiff</i> and PDF.</p> -<!-- INDENTATION --> -<p>If you have multiple TIFF files to convert into one PDF -file then use <i>tiffcp</i> or other program to concatenate -the files into a multiple page TIFF file. If the input TIFF -file is of huge dimensions (greater than 10000 pixels height -or width) convert the input image to a tiled TIFF if it is -not already.</p> -<!-- INDENTATION --> -<p>The standard output is standard output. Set the output -file name with the <b>−o</b> <i>output.pdf</i> -option.</p> -<!-- INDENTATION --> -<p>All black and white files are compressed into a single -strip CCITT G4 Fax compressed PDF, unless tiled, where tiled -black and white images are compressed into tiled CCITT G4 -Fax compressed PDF, <i>libtiff</i> CCITT support is -assumed.</p> -<!-- INDENTATION --> -<p>Color and grayscale data can be compressed using either -JPEG compression, ITU-T T.81, or Zip/Deflate LZ77 -compression. Set the compression type using the -<b>−j</b> or <b>−z</b> options. JPEG compression -support requires that <i>libtiff</i> be configured with JPEG -support, and Zip/Deflate compression support requires that -<i>libtiff</i> be configured with Zip support, in -tiffconf.h. Use only one or the other of <b>−j</b> and -<b>−z.</b></p> -<!-- INDENTATION --> -<p>If the input TIFF contains single strip CCITT G4 Fax -compressed information, then that is written to the PDF file -without transcoding, unless the options of no compression -and no passthrough are set, <b>−d</b> and -<b>−n.</b></p> -<!-- INDENTATION --> -<p>If the input TIFF contains JPEG or single strip -Zip/Deflate compressed information, and they are configured, -then that is written to the PDF file without transcoding, -unless the options of no compression and no passthrough are -set.</p> -<!-- INDENTATION --> -<p>The default page size upon which the TIFF image is placed -is determined by the resolution and extent of the image -data. Default values for the TIFF image resolution can be -set using the <b>−x</b> and <b>−y</b> options. -The page size can be set using the <b>−p</b> option -for paper size, or <b>−w</b> and <b>−l</b> for -paper width and length, then each page of the TIFF image is -centered on its page. The distance unit for default -resolution and page width and length can be set by the -<b>−u</b> option, the default unit is inch.</p> -<!-- INDENTATION --> -<p>Various items of the output document information can be -set with the <b>−e</b>, <b>−c</b>, -<b>−a</b>, <b>−t</b>, <b>−s</b>, and -<b>−k</b> options. Setting the argument of the option -to "" for these tags causes the relevant document -information field to be not written. Some of the document -information values otherwise get their information from the -input TIFF image, the software, author, document name, and -image description.</p> -<!-- INDENTATION --> -<p>The Portable Document Format (PDF) specification is -copyrighted by Adobe Systems, Incorporated.</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="89%"> -<p><b>−o</b> <i>output-file</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="21%"></td> -<td width="77%"> -<p>Set the output to go to file. <i>output-file</i></p> -</td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="4" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="11%"></td> -<td width="4%"> - -<p><b>−j</b></p> -</td> -<td width="5%"></td> -<td width="77%"> - -<p>Compress with JPEG (requires <i>libjpeg</i> configured -with <i>libtiff</i>).</p> -</td> -<tr valign="top" align="left"> -<td width="11%"></td> -<td width="4%"> - -<p><b>−z</b></p> -</td> -<td width="5%"></td> -<td width="77%"> - -<p>Compress with Zip/Deflate (requires <i>zlib</i> -configured with <i>libtiff</i>).</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="89%"> -<p><b>−q</b> <i>quality</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="21%"></td> -<td width="77%"> -<p>Set the compression quality, 1-100 for JPEG.</p> -</td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="4" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="11%"></td> -<td width="2%"> - -<p><b>−n</b></p> -</td> -<td width="7%"></td> -<td width="77%"> - -<p>Do not allow data to be converted without uncompressing, -no compressed data passthrough.</p> -</td> -<tr valign="top" align="left"> -<td width="11%"></td> -<td width="2%"> - -<p><b>−b</b></p> -</td> -<td width="7%"></td> -<td width="77%"> - -<p>Set PDF ‘‘Interpolate’’ user -preference.</p> -</td> -<tr valign="top" align="left"> -<td width="11%"></td> -<td width="2%"> - -<p><b>−d</b></p> -</td> -<td width="7%"></td> -<td width="77%"> - -<p>Do not compress (decompress).</p> -</td> -<tr valign="top" align="left"> -<td width="11%"></td> -<td width="2%"> - -<p><b>−i</b></p> -</td> -<td width="7%"></td> -<td width="77%"> - -<p>Invert colors.</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="89%"> -<p><b>−p</b> <i>paper-size</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="21%"></td> -<td width="77%"> -<p>Set paper size, e.g., <b>letter</b>, <b>legal</b>, -<b>A4</b>.</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="89%"> -<p><b>−u</b> [<b>i</b>|<b>m</b>]</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="21%"></td> -<td width="77%"> -<p>Set distance unit, <b>i</b> for inch, <b>m</b> for -centimeter.</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="89%"> -<p><b>−w</b> <i>width</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="21%"></td> -<td width="77%"> -<p>Set width in units.</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="89%"> -<p><b>−l</b> <i>length</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="21%"></td> -<td width="77%"> -<p>Set length in units.</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="89%"> -<p><b>−x</b> <i>xres</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="21%"></td> -<td width="77%"> -<p>Set x/width resolution default.</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="89%"> -<p><b>−y</b> <i>yres</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="21%"></td> -<td width="77%"> -<p>Set y/length resolution default.</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="89%"> -<p><b>−r</b> [<b>d</b>|<b>o</b>]</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="21%"></td> -<td width="77%"> -<p>Set <b>d</b> for resolution default for images without -resolution, <b>o</b> for resolution override for all -images.</p> -</td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="11%"></td> -<td width="2%"> - -<p><b>−f</b></p> -</td> -<td width="13%"></td> -<td width="57%"> - -<p>Set PDF ‘‘Fit Window’’ user -preference.</p> -</td> -<td width="14%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="89%"> -<p><b>−e</b> <i>YYYYMMDDHHMMSS</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="21%"></td> -<td width="77%"> -<p>Set document information date, overrides image or current -date/time default, <i>YYYYMMDDHHMMSS.</i></p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="89%"> -<p><b>−c</b> <i>creator</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="21%"></td> -<td width="77%"> -<p>Set document information creator, overrides image -software default.</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="89%"> -<p><b>−a</b> <i>author</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="21%"></td> -<td width="77%"> -<p>Set document information author, overrides image artist -default.</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="89%"> -<p><b>−t</b> <i>title</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="21%"></td> -<td width="77%"> -<p>Set document information title, overrides image document -name default.</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="89%"> -<p><b>−s</b> <i>subject</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="21%"></td> -<td width="77%"> -<p>Set document information subject, overrides image image -description default.</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="89%"> -<p><b>−k</b> <i>keywords</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="21%"></td> -<td width="77%"> -<p>Set document information keywords.</p> -</td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="11%"></td> -<td width="2%"> - -<p><b>−h</b></p> -</td> -<td width="13%"></td> -<td width="57%"> - -<p>List usage reminder to stderr and exit.</p> -</td> -<td width="14%"> -</td> -</table> -<a name="EXAMPLES"></a> -<h2>EXAMPLES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="89%"> -<p>The following example would generate the file output.pdf -from input.tiff.</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="20%"></td> -<td width="79%"> -<pre>tiff2pdf −o output.pdf input.tiff -</pre> -</td> -</table> -<!-- INDENTATION --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="89%"> -<p>The following example would generate PDF output from -input.tiff and write it to standard output.</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="20%"></td> -<td width="79%"> -<pre>tiff2pdf input.tiff -</pre> -</td> -</table> -<!-- INDENTATION --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="89%"> -<p>The following example would generate the file output.pdf -from input.tiff, putting the image pages on a letter sized -page, compressing the output with JPEG, with JPEG quality -75, setting the title to -‘‘Document’’, and setting the -‘‘Fit Window’’ option.</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="20%"></td> -<td width="79%"> -<pre>tiff2pdf −p letter −j −q 75 −t "Document" −f −o output.pdf input.tiff -</pre> -</td> -</table> -<a name="BUGS"></a> -<h2>BUGS</h2> -<!-- INDENTATION --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="89%"> -<p>Please report bugs via the web interface at</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="20%"></td> -<td width="79%"> - -<p>http://bugzilla.remotesensing.org/enter_bug.cgi?product=libtiff</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="89%"> -<p><b>libtiff</b>(3), <b>tiffcp</b>(1), -<b>tiff2ps</b>(1)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/tiff2ps.1.html b/src/3rdparty/libtiff/html/man/tiff2ps.1.html deleted file mode 100644 index e13bb8f..0000000 --- a/src/3rdparty/libtiff/html/man/tiff2ps.1.html +++ /dev/null @@ -1,532 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:19 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFF2PS</title> -</head> -<body> - -<h1 align=center>TIFF2PS</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#EXAMPLES">EXAMPLES</a><br> -<a href="#BUGS">BUGS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>tiff2ps − convert a <small>TIFF</small> image to -PostScript™</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiff2ps</b> [ <i>options</i> ] <i>input.tif -...</i></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>tiff2ps</i> reads <small>TIFF</small> images and -writes PostScript or Encapsulated PostScript (EPS) on the -standard output. By default, <i>tiff2ps</i> writes -Encapsulated PostScript for the first image in the specified -<small>TIFF</small> image file.</p> -<!-- INDENTATION --> -<p>By default, <i>tiff2ps</i> will generate PostScript that -fills a printed area specified by the <small>TIFF</small> -tags in the input file. If the file does not contain -<i>XResolution</i> or <i>YResolution</i> tags, then the -printed area is set according to the image dimensions. The -<b>−w</b> and <b>−h</b> options (see below) can -be used to set the dimensions of the printed area in inches; -overriding any relevant <small>TIFF</small> tags.</p> -<!-- INDENTATION --> -<p>The PostScript generated for <small>RGB,</small> palette, -and <small>CMYK</small> images uses the <i>colorimage</i> -operator. The PostScript generated for greyscale and bilevel -images uses the <i>image</i> operator. When the -<i>colorimage</i> operator is used, PostScript code to -emulate this operator on older PostScript printers is also -generated. Note that this emulation code can be very -slow.</p> -<!-- INDENTATION --> -<p>Color images with associated alpha data are composited -over a white background.</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−1</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Generate PostScript Level 1 (the default).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−2</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Generate PostScript Level 2.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−3</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Generate PostScript Level 3. It basically allows one to -use the /flateDecode filter for ZIP compressed TIFF -images.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−a</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Generate output for all IFDs (pages) in the input -file.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−b</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the bottom margin for the output (in inches). -This does not affect the height of the printed image.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−c</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Center the image in the output. This option only shows -an effect if both the <b>−w</b> and the -<b>−h</b> option are given.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−d</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Set the initial <small>TIFF</small> directory to the -specified directory number. (NB: Directories are numbered -starting at zero.) This option is useful for selecting -individual pages in a multi-page (e.g. facsimile) file.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−e</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force the generation of Encapsulated PostScript (implies -<b>−z</b>).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−h</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the vertical size of the printed area (in -inches).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−H</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the maximum height of image (in inches). Images -with larger sizes will be split in several pages. Option -<b>−L</b> may be used for specifying size of split -images overlapping.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−i</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Enable/disable pixel interpolation. This option requires -a single numeric value: zero to disable pixel interpolation -and non-zero to enable. The default is enabled.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−L</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the size of overlapping for split images (in -inches). Used in conjunction with <b>−H</b> -option.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−l</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the left margin for the output (in inches). This -does not affect the width of the printed image.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−m</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Where possible render using the <i>imagemask</i> -PostScript operator instead of the <i>image</i> operator. -When this option is specified <i>tiff2ps</i> will use -<i>imagemask</i> for rendering 1 bit deep images. If this -option is not specified or if the image depth is greater -than 1 then the <i>image</i> operator is used.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−o</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Set the initial <small>TIFF</small> directory to the -<small>IFD</small> at the specified file offset. This option -is useful for selecting thumbnail images and the like which -are hidden using the <i>SubIFD</i> tag.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−p</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force the generation of (non-Encapsulated) -PostScript.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−r</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Rotate image by 180 degrees.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−s</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Generate output for a single IFD (page) in the input -file.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−w</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the horizontal size of the printed area (in -inches).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−x</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Override resolution units specified in the TIFF as -centimeters.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−y</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Override resolution units specified in the TIFF as -inches.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−z</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>When generating PostScript Level 2, data is scaled so -that it does not image into the <i>deadzone</i> on a page -(the outer margin that the printing device is unable to -mark). This option suppresses this behavior. When PostScript -Level 1 is generated, data is imaged to the entire printed -page and this option has no affect.</p> -</td> -<td width="0%"> -</td> -</table> -<a name="EXAMPLES"></a> -<h2>EXAMPLES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The following generates PostScript Level 2 for all pages -of a facsimile:</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>tiff2ps −a2 fax.tif | lpr -</pre> -</td> -</table> -<!-- INDENTATION --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Note also that if you have version 2.6.1 or newer of -Ghostscript then you can efficiently preview facsimile -generated with the above command.</p> -<!-- INDENTATION --> -<p>To generate Encapsulated PostScript for a the image at -directory 2 of an image use:</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>tiff2ps −d 1 foo.tif -</pre> -</td> -</table> -<!-- INDENTATION --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>(Notice that directories are numbered starting at -zero.)</p> -<!-- INDENTATION --> -<p>If you have a long image, it may be split in several -pages:</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>tiff2ps −h11 −w8.5 −H14 −L.5 foo.tif > foo.ps -</pre> -</td> -</table> -<!-- INDENTATION --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The page size is set to 8.5x11 by <b>−w</b> and -<b>−h</b> options. We will accept a small amount of -vertical compression, so <b>−H</b> set to 14. Any -pages between 11 and 14 inches will be fit onto one page. -Pages longer than 14 inches are cut off at 11 and continued -on the next page. The <b>−L.5</b> option says to -repeat a half inch on the next page (to improve -readability).</p> -</td> -</table> -<a name="BUGS"></a> -<h2>BUGS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Because PostScript does not support the notion of a -colormap, 8-bit palette images produce 24-bit PostScript -images. This conversion results in output that is six times -bigger than the original image and which takes a long time -to send to a printer over a serial line. Matters are even -worse for 4-, 2-, and 1-bit palette images.</p> -<!-- INDENTATION --> -<p>Does not handle tiled images when generating PostScript -Level I output.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>pal2rgb</b>(1), <b>tiffinfo</b>(1), <b>tiffcp</b>(1), -<b>tiffgt</b>(1), <b>tiffmedian</b>(1), <b>tiff2bw</b>(1), -<b>tiffsv</b>(1), <b>libtiff</b>(3)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/tiff2rgba.1.html b/src/3rdparty/libtiff/html/man/tiff2rgba.1.html deleted file mode 100644 index eec3968..0000000 --- a/src/3rdparty/libtiff/html/man/tiff2rgba.1.html +++ /dev/null @@ -1,162 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:19 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFF2RGBA</title> -</head> -<body> - -<h1 align=center>TIFF2RGBA</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>tiff2rgba − convert a <small>TIFF</small> image to -RGBA color space</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiff2rgba</b> [ <i>options</i> ] <i>input.tif -output.tif</i></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>Tiff2rgba</i> converts a wide variety of TIFF images -into an RGBA TIFF image. This includes the ability to -translate different color spaces and photometric -interpretation into RGBA, support for alpha blending, and -translation of many different bit depths into a 32bit RGBA -image.</p> -<!-- INDENTATION --> -<p>Internally this program is implemented using the -<i>TIFFReadRGBAImage()</i> function, and it suffers any -limitations of that image. This includes limited support for -> 8 BitsPerSample images, and flaws with some esoteric -combinations of BitsPerSample, photometric interpretation, -block organization and planar configuration.</p> -<!-- INDENTATION --> -<p>The generated images are stripped images with four -samples per pixel (red, green, blue and alpha) or if the -<b>−n</b> flag is used, three samples per pixel (red, -green, and blue). The resulting images are always planar -configuration contiguous. For this reason, this program is a -useful utility for transform exotic TIFF files into a form -ingestible by almost any TIFF supporting software.</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="11%"></td> -<td width="2%"> - -<p><b>−c</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify a compression scheme to use when writing image -data: <b>−c none</b> for no compression (the default), -<b>−c packbits</b> for the PackBits compression -algorithm, <b>−c zip</b> for the Deflate compression -algorithm, <b>−c jpeg</b> for the JPEG compression -algorithm, and <b>−c lzw</b> for Lempel-Ziv & -Welch.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="11%"></td> -<td width="2%"> - -<p><b>−r</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Write data with a specified number of rows per strip; by -default the number of rows/strip is selected so that each -strip is approximately 8 kilobytes.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="11%"></td> -<td width="2%"> - -<p><b>−b</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Process the image one block (strip/tile) at a time -instead of by reading the whole image into memory at once. -This may be necessary for very large images on systems with -limited RAM.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="11%"></td> -<td width="2%"> - -<p><b>−n</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Drop the alpha component from the output file, producing -a pure RGB file. Currently this does not work if the -<b>−b</b> flag is also in effect.</p> -</td> -<td width="0%"> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiff2bw</b>(1), <b>TIFFReadRGBAImage</b>(3t), -<b>libtiff</b>(3)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/tiffcmp.1.html b/src/3rdparty/libtiff/html/man/tiffcmp.1.html deleted file mode 100644 index a9fca2f..0000000 --- a/src/3rdparty/libtiff/html/man/tiffcmp.1.html +++ /dev/null @@ -1,156 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:19 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFCMP</title> -</head> -<body> - -<h1 align=center>TIFFCMP</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#BUGS">BUGS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>tiffcmp − compare two <small>TIFF</small> files</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiffcmp</b> [ <i>options</i> ] <i>file1.tif -file2.tif</i></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>Tiffcmp</i> compares the tags and data in two files -created according to the Tagged Image File Format, Revision -6.0. The schemes used for compressing data in each file are -immaterial when data are compared−data are compared on -a scanline-by-scanline basis after decompression. Most -directory tags are checked; notable exceptions are: -<i>GrayResponseCurve</i>, <i>ColorResponseCurve</i>, and -<i>ColorMap</i> tags. Data will not be compared if any of -the <i>BitsPerSample</i>, <i>SamplesPerPixel</i>, or -<i>ImageWidth</i> values are not equal. By default, -<i>tiffcmp</i> will terminate if it encounters any -difference.</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="11%"></td> -<td width="2%"> - -<p><b>−l</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>List each byte of image data that differs between the -files.</p> -</td> -<td width="0%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−z</b> <i>number</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>List specified number of image data bytes that differs -between the files.</p> -</td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="2%"> - -<p><b>−t</b></p> -</td> -<td width="11%"></td> -<td width="52%"> - -<p>Ignore any differences in directory tags.</p> -</td> -<td width="23%"> -</td> -</table> -<a name="BUGS"></a> -<h2>BUGS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Tags that are not recognized by the library are not -compared; they may also generate spurious diagnostics.</p> -<!-- INDENTATION --> -<p>The image data of tiled files is not compared, since the -<i>TIFFReadScanline()</i> function is used. An error will be -reported for tiled files.</p> -<!-- INDENTATION --> -<p>The pixel and/or sample number reported in differences -may be off in some exotic cases.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>pal2rgb</b>(1), <b>tiffcp</b>(1), -<b>tiffmedian</b>(1), <b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/tiffcp.1.html b/src/3rdparty/libtiff/html/man/tiffcp.1.html deleted file mode 100644 index 2b30d5f..0000000 --- a/src/3rdparty/libtiff/html/man/tiffcp.1.html +++ /dev/null @@ -1,522 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:19 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFCP</title> -</head> -<body> - -<h1 align=center>TIFFCP</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#EXAMPLES">EXAMPLES</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>tiffcp − copy (and possibly convert) a -<small>TIFF</small> file</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiffcp</b> [ <i>options</i> ] <i>src1.tif ... srcN.tif -dst.tif</i></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>tiffcp</i> combines one or more files created -according to the Tag Image File Format, Revision 6.0 into a -single <small>TIFF</small> file. Because the output file may -be compressed using a different algorithm than the input -files, <i>tiffcp</i> is most often used to convert between -different compression schemes.</p> -<!-- INDENTATION --> -<p>By default, <i>tiffcp</i> will copy all the understood -tags in a <small>TIFF</small> directory of an input file to -the associated directory in the output file.</p> -<!-- INDENTATION --> -<p><i>tiffcp</i> can be used to reorganize the storage -characteristics of data in a file, but it is explicitly -intended to not alter or convert the image data content in -any way.</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−b</b> <i>image</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>subtract the following monochrome image from all others -processed. This can be used to remove a noise bias from a -set of images. This bias image is typically an image of -noise the camera saw with its shutter closed.</p> -</td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−B</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force output to be written with Big-Endian byte order. -This option only has an effect when the output file is -created or overwritten and not when it is appended to.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−C</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Suppress the use of ‘‘strip -chopping’’ when reading images that have a -single strip/tile of uncompressed data.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−c</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the compression to use for data written to the -output file: <b>none</b> for no compression, <b>packbits</b> -for PackBits compression, <b>lzw</b> for Lempel-Ziv & -Welch compression, <b>jpeg</b> for baseline JPEG -compression, <b>zip</b> for Deflate compression, <b>g3</b> -for CCITT Group 3 (T.4) compression, and <b>g4</b> for CCITT -Group 4 (T.6) compression. By default <i>tiffcp</i> will -compress data according to the value of the -<i>Compression</i> tag found in the source file.</p> -</td> -<td width="0%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<p>The <small>CCITT</small> Group 3 and Group 4 compression -algorithms can only be used with bilevel data.</p> -<!-- INDENTATION --> -<p>Group 3 compression can be specified together with -several T.4-specific options: <b>1d</b> for 1-dimensional -encoding, <b>2d</b> for 2-dimensional encoding, and -<b>fill</b> to force each encoded scanline to be zero-filled -so that the terminating EOL code lies on a byte boundary. -Group 3-specific options are specified by appending a -‘‘:’’-separated list to the -‘‘g3’’ option; e.g. <b>−c -g3:2d:fill</b> to get 2D-encoded data with byte-aligned EOL -codes.</p> -<!-- INDENTATION --> -<p><small>LZW</small> compression can be specified together -with a <i>predictor</i> value. A predictor value of 2 causes -each scanline of the output image to undergo horizontal -differencing before it is encoded; a value of 1 forces each -scanline to be encoded without differencing. LZW-specific -options are specified by appending a -‘‘:’’-separated list to the -‘‘lzw’’ option; e.g. <b>−c -lzw:2</b> for <small>LZW</small> compression with horizontal -differencing.</p> -</td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−f</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the bit fill order to use in writing output -data. By default, <i>tiffcp</i> will create a new file with -the same fill order as the original. Specifying <b>−f -lsb2msb</b> will force data to be written with the FillOrder -tag set to <small>LSB2MSB,</small> while <b>−f -msb2lsb</b> will force data to be written with the FillOrder -tag set to <small>MSB2LSB.</small></p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−i</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Ignore non-fatal read errors and continue processing of -the input file.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−l</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the length of a tile (in pixels). <i>tiffcp</i> -attempts to set the tile dimensions so that no more than 8 -kilobytes of data appear in a tile.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−L</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force output to be written with Little-Endian byte -order. This option only has an effect when the output file -is created or overwritten and not when it is appended -to.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−M</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Suppress the use of memory-mapped files when reading -images.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−p</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the planar configuration to use in writing image -data that has one 8-bit sample per pixel. By default, -<i>tiffcp</i> will create a new file with the same planar -configuration as the original. Specifying <b>−p -contig</b> will force data to be written with multi-sample -data packed together, while <b>−p separate</b> will -force samples to be written in separate planes.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−r</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the number of rows (scanlines) in each strip of -data written to the output file. By default (or when value -<b>0</b> is specified), <i>tiffcp</i> attempts to set the -rows/strip that no more than 8 kilobytes of data appear in a -strip. If you specify special value <b>−1</b> it will -results in infinite number of the rows per strip. The entire -image will be the one strip in that case.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−s</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force the output file to be written with data organized -in strips (rather than tiles).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−t</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force the output file to be written with data organized -in tiles (rather than strips). options can be used to force -the resultant image to be written as strips or tiles of -data, respectively.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−w</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the width of a tile (in pixels). <i>tiffcp</i> -attempts to set the tile dimensions so that no more than 8 -kilobytes of data appear in a tile. <i>tiffcp</i> attempts -to set the tile dimensions so that no more than 8 kilobytes -of data appear in a tile.</p> -</td> -<td width="0%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−,=</b><i>character</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>substitute <i>character</i> for ‘,’ in -parsing image directory indices in files. This is necessary -if filenames contain commas. Note that <b>−,=</b> with -whitespace immediately following will disable the special -meaning of the ‘,’ entirely. See examples.</p> -</td> -</table> -<a name="EXAMPLES"></a> -<h2>EXAMPLES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The following concatenates two files and writes the -result using <small>LZW</small> encoding:</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>tiffcp −c lzw a.tif b.tif result.tif -</pre> -</td> -</table> -<!-- INDENTATION --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>To convert a G3 1d-encoded <small>TIFF</small> to a -single strip of G4-encoded data the following might be -used:</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>tiffcp −c g4 −r 10000 g3.tif g4.tif -</pre> -</td> -</table> -<!-- INDENTATION --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>(1000 is just a number that is larger than the number of -rows in the source file.)</p> -<!-- INDENTATION --> -<p>To extract a selected set of images from a multi-image -TIFF file, the file name may be immediately followed by a -‘,’ separated list of image directory indices. -The first image is always in directory 0. Thus, to copy the -1st and 3rd images of image file -‘‘album.tif’’ to -‘‘result.tif’’:</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>tiffcp album.tif,0,2 result.tif -</pre> -</td> -</table> -<!-- INDENTATION --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>A trailing comma denotes remaining images in sequence. -The following command will copy all image with except the -first one:</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>tiffcp album.tif,1, result.tif -</pre> -</td> -</table> -<!-- INDENTATION --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Given file ‘‘CCD.tif’’ whose -first image is a noise bias followed by images which include -that bias, subtract the noise from all those images -following it (while decompressing) with the -command:</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>tiffcp −c none −b CCD.tif CCD.tif,1, result.tif -</pre> -</td> -</table> -<!-- INDENTATION --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>If the file above were named -‘‘CCD,X.tif’’, the <b>−,=</b> -option would be required to correctly parse this filename -with image numbers, as follows:</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>tiffcp −c none −,=% −b CCD,X.tif CCD,X%1%.tif result.tif - -</pre> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>pal2rgb</b>(1), <b>tiffinfo</b>(1), <b>tiffcmp</b>(1), -<b>tiffmedian</b>(1), <b>tiffsplit</b>(1), -<b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/tiffcrop.1.html b/src/3rdparty/libtiff/html/man/tiffcrop.1.html deleted file mode 100644 index 4c25c29..0000000 --- a/src/3rdparty/libtiff/html/man/tiffcrop.1.html +++ /dev/null @@ -1,851 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:19 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFCROP</title> -</head> -<body> - -<h1 align=center>TIFFCROP</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#EXAMPLES">EXAMPLES</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>tiffcrop − copy, convert, crop, extract, or process -a <small>TIFF</small> file</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiffcrop</b> [ <i>options</i> ] <i>src1.tif ... -srcN.tif dst.tif</i></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>tiffcrop</i> combines one or more files created -according to the Tag Image File Format, Revision 6.0 into a -single <small>TIFF</small> file. The output file may be -compressed using a different algorithm than the input files. -<i>tiffcrop</i> is most often used to extract portions of an -image for processing with bar code recognizer or OCR -software when that software cannot restrict the region of -interest to a specific portion of the image or to improve -efficiency when the regions of interest must be rotated. It -can also be used to subdivide all or part of a processed -image into smaller sections.</p> -<!-- INDENTATION --> -<p>Functions are applied to the input image in the following -order:</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>cropping, fixed area extraction, zones, inversion, mirroring, rotation. -</pre> -</td> -</table> -<!-- INDENTATION --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Functions are applied to the output image in the -following order:</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<p>output resolution, output margins, rows and columns -<b>or</b> page size divisions, orientation options, strip, -tile, byte order, and compression options.</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>By default, <i>tiffcrop</i> will copy all the understood -tags in a <small>TIFF</small> directory of an input file to -the associated directory in the output file. Options can be -used to force the resultant image to be written as strips or -tiles of data, respectively.</p> -<!-- INDENTATION --> -<p><i>tiffcrop</i> can be used to reorganize the storage -characteristics of data in a file, and to reorganize, -extract, rotate, and otherwise process the image data as -specified at the same time whereas tiffcp does not alter the -image data itself.</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−N odd|even|#,#-#,#|last</b></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>Specify one or more series or range(s) of images within -file to process. The words <b>odd</b> or <b>even</b> may be -used to specify all odd or even numbered images. The word -<b>last</b> may be used in place of a number in the sequence -to indicate the final image in the file without knowing how -many images there are. Ranges of images may be specified -with a dash and multiple sets can be indicated by joining -them in a comma-separated list. eg. use <b>−N -1,5-7,last</b> to process the 1st, 5th through 7th, and -final image in the file.</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−E top|bottom|left|right</b></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>Specify the top, bottom, left, or right edge as the -reference from which to calcuate the width and length of -crop regions or sequence of postions for zones. May be -abbreviated to first letter.</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−U in|cm|px</b></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>Specify the type of units to apply to dimensions for -margins and crop regions for input and output images. Inches -or centimeters are converted to pixels using the resolution -unit specified in the TIFF file (which defaults to inches if -not specified in the IFD).</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−m #,#,#,#</b></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>Specify margins to be removed from the input image. The -order must be top, left, bottom, right with only commas -separating the elements of the list. Margins are scaled -according to the current units and removed before any other -extractions are computed. Captial M was in use.</p> -</td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="6%"> - -<p><b>−X #</b></p> -</td> -<td width="2%"></td> -<td width="80%"> - -<p>Set the horizontal (X-axis) dimension of a region to -extract relative to the specified origin reference. If the -origin is the top or bottom edge, the X axis value will be -assumed to start at the left edge.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="6%"> - -<p><b>−Y #</b></p> -</td> -<td width="2%"></td> -<td width="80%"> - -<p>Set the vertical (Y-axis) dimension of a region to -extract relative to the specified origin reference. If the -origin is the left or right edge, the Y axis value will be -assumed to start at the top.</p> -</td> -<td width="0%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−Z #:#,#:#</b></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>Specify zones of the image designated as position X of Y -equal sized portions measured from the reference edge, eg -1:3 would be first third of the image starting from the -reference edge minus any margins specified for the confining -edges. Multiple zones can be specified as a comma separated -list but they must reference the same edge. To extract the -top quarter and the bottom third of an image you would use -<b>−Z 1:4,3:3.</b></p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−F horiz|vert</b></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>Flip, ie mirror, the image or extracted region -horizontally or vertically.</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−R 90|180|270</b></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>Rotate the image or extracted region 90, 180, or 270 -degrees clockwise.</p> -</td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="6%"> - -<p><b>−I</b></p> -</td> -<td width="2%"></td> -<td width="80%"> - -<p>Invert the colorspace values for grayscale and bilevel -images. This would be used to correct negative images that -have incorrect PHOTMETRIC INTERPRETATION tags. No support -for color images.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="6%"> - -<p><b>−H #</b></p> -</td> -<td width="2%"></td> -<td width="80%"> - -<p>Set the horizontal resolution of output images to # -expressed in the current units.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="6%"> - -<p><b>−V #</b></p> -</td> -<td width="2%"></td> -<td width="80%"> - -<p>Set the vertical resolution of the output images to # -expressed in the current units.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="6%"> - -<p><b>−J #</b></p> -</td> -<td width="2%"></td> -<td width="80%"> - -<p>Set the horizontal margin of an output page size to # -expressed in the current units.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="6%"> - -<p><b>−K #</b></p> -</td> -<td width="2%"></td> -<td width="80%"> - -<p>Set the vertical margin of an output page size to # -expressed in the current units.</p> -</td> -<td width="0%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−O portrait|landscape|auto</b></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>Set the output orientation of the pages or sections. Auto -will use the arrangement that requires the fewest pages.</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−S cols:rows</b></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>Divide each image into cols across and rows down equal -sections.</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−P page</b></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>Format the output images to fit on page size paper. Use --P list to show the supported page sizes and dimensions.</p> -</td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−B</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force output to be written with Big-Endian byte order. -This option only has an effect when the output file is -created or overwritten and not when it is appended to.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−C</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Suppress the use of ‘‘strip -chopping’’ when reading images that have a -single strip/tile of uncompressed data.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−c</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the compression to use for data written to the -output file: <b>none</b> for no compression, <b>packbits</b> -for PackBits compression, <b>lzw</b> for Lempel-Ziv & -Welch compression, <b>jpeg</b> for baseline JPEG -compression, <b>zip</b> for Deflate compression, <b>g3</b> -for CCITT Group 3 (T.4) compression, and <b>g4</b> for CCITT -Group 4 (T.6) compression. By default <i>tiffcrop</i> will -compress data according to the value of the -<i>Compression</i> tag found in the source file.</p> -</td> -<td width="0%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<p>The <small>CCITT</small> Group 3 and Group 4 compression -algorithms can only be used with bilevel data.</p> -<!-- INDENTATION --> -<p>Group 3 compression can be specified together with -several T.4-specific options: <b>1d</b> for 1-dimensional -encoding, <b>2d</b> for 2-dimensional encoding, and -<b>fill</b> to force each encoded scanline to be zero-filled -so that the terminating EOL code lies on a byte boundary. -Group 3-specific options are specified by appending a -‘‘:’’-separated list to the -‘‘g3’’ option; e.g. <b>−c -g3:2d:fill</b> to get 2D-encoded data with byte-aligned EOL -codes.</p> -<!-- INDENTATION --> -<p><small>LZW</small> compression can be specified together -with a <i>predictor</i> value. A predictor value of 2 causes -each scanline of the output image to undergo horizontal -differencing before it is encoded; a value of 1 forces each -scanline to be encoded without differencing. LZW-specific -options are specified by appending a -‘‘:’’-separated list to the -‘‘lzw’’ option; e.g. <b>−c -lzw:2</b> for <small>LZW</small> compression with horizontal -differencing.</p> -</td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−f</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the bit fill order to use in writing output -data. By default, <i>tiffcrop</i> will create a new file -with the same fill order as the original. Specifying -<b>−f lsb2msb</b> will force data to be written with -the FillOrder tag set to <small>LSB2MSB,</small> while -<b>−f msb2lsb</b> will force data to be written with -the FillOrder tag set to <small>MSB2LSB.</small></p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−i</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Ignore non-fatal read errors and continue processing of -the input file.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−l</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the length of a tile (in pixels). -<i>tiffcrop</i> attempts to set the tile dimensions so that -no more than 8 kilobytes of data appear in a tile.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−L</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force output to be written with Little-Endian byte -order. This option only has an effect when the output file -is created or overwritten and not when it is appended -to.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−M</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Suppress the use of memory-mapped files when reading -images.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−p</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the planar configuration to use in writing image -data that has more than one 8-bit sample per pixel. By -default, <i>tiffcrop</i> will create a new file with the -same planar configuration as the original. Specifying -<b>−p contig</b> will force data to be written with -multi-sample data packed together, while <b>−p -separate</b> will force samples to be written in separate -planes.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−r</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the number of rows (scanlines) in each strip of -data written to the output file. By default (or when value -<b>0</b> is specified), <i>tiffcrop</i> attempts to set the -rows/strip that no more than 8 kilobytes of data appear in a -strip. If you specify the special value <b>-1</b> it will -results in infinite number of the rows per strip. The entire -image will be the one strip in that case.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−s</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force the output file to be written with data organized -in strips (rather than tiles).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−t</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force the output file to be written with data organized -in tiles (rather than strips).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−w</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the width of a tile (in pixels). <i>tiffcrop</i> -attempts to set the tile dimensions so that no more than 8 -kilobytes of data appear in a tile. <i>tiffcrop</i> attempts -to set the tile dimensions so that no more than 8 kilobytes -of data appear in a tile.</p> -</td> -<td width="0%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−,={character}</b></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>substitute {character} for ’,’ in parsing -image directory indices in files. This is necessary if -filenames contain commas. Note that ’,=’ with -whitespace immediately following will disable the special -meaning of the ’,’ entirely. See examples.</p> -</td> -</table> -<a name="EXAMPLES"></a> -<h2>EXAMPLES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The following concatenates two files and writes the -result using <small>LZW</small> encoding:</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>tiffcrop -c lzw a.tif b.tif result.tif -</pre> -</td> -</table> -<!-- INDENTATION --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>To convert a G3 1d-encoded <small>TIFF</small> to a -single strip of G4-encoded data the following might be -used:</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>tiffcrop -c g4 -r 10000 g3.tif g4.tif -</pre> -</td> -</table> -<!-- INDENTATION --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>(1000 is just a number that is larger than the number of -rows in the source file.)</p> -<!-- INDENTATION --> -<p>To extract a selected set of images from a multi-image -TIFF file use the -N option described above. Thus, to copy -the 1st and 3rd images of image file "album.tif" -to "result.tif":</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>tiffcrop -N 1,3 album.tif result.tif -</pre> -</td> -</table> -<!-- INDENTATION --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Invert a bilevel image scan of a microfilmed document and -crop off margins of 0.25 inches on the left and right, 0.5 -inch on the top, nad 0.75 inch on the bottom. From the -remaining portion of the image, select the second and third -quarters, ie, one half of the area left from the center to -each margin.</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>tiffcrop -U in -m 0.5,0.25,0.75,0.25 -E left -Z 2:4,3:4 -I MicrofilmNegative.tif MicrofilmPostiveCenter.tif -</pre> -</td> -</table> -<!-- INDENTATION --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Extract only the final image of a large Architectural E -sized multipage TIFF file and rotate it 90 degrees clockwise -while reformatting the output to fit on tabloid sized sheets -with one quarter of an inch on each side:</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>tiffcrop -N last -R 90 -O auto -P tabloid -U in -J 0.25 -K 0.25 -H 300 -V 300 Big-PlatMap.tif BigPlatMap-Tabloid.tif -</pre> -</td> -</table> -<!-- INDENTATION --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The output images will have a specified resolution of 300 -dpi in both directions. The orientation of each page will be -determined by whichever choice requires the fewest pages. To -specify a specific orientation, use the portrait or -landscape option.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>pal2rgb</b>(1), <b>tiffinfo</b>(1), <b>tiffcmp</b>(1), -<b>tiffcp</b>(1), <b>tiffmedian</b>(1), <b>tiffsplit</b>(1), -<b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/tiffdither.1.html b/src/3rdparty/libtiff/html/man/tiffdither.1.html deleted file mode 100644 index 2427a90..0000000 --- a/src/3rdparty/libtiff/html/man/tiffdither.1.html +++ /dev/null @@ -1,183 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:19 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFDITHER</title> -</head> -<body> - -<h1 align=center>TIFFDITHER</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#NOTES">NOTES</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>tiffdither − convert a greyscale image to bilevel -using dithering</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiffdither</b> [ <i>options</i> ] <i>input.tif -output.tif</i></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>tiffdither</i> converts a single channel 8-bit -greyscale image to a bilevel image using Floyd-Steinberg -error propagation with thresholding.</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="2%"> - -<p><b>−c</b></p> -</td> -<td width="6%"></td> -<td width="80%"> - -<p>Specify the compression to use for data written to the -output file: <b>none</b> for no compression, <b>packbits</b> -for PackBits compression, <b>lzw</b> for Lempel-Ziv & -Welch compression, <b>zip</b> for Deflate compression, -<b>g3</b> for CCITT Group 3 (T.4) compression, and <b>g4</b> -for CCITT Group 4 (T.6) compression. By default -<i>tiffdither</i> will compress data according to the value -of the <i>Compression</i> tag found in the source file.</p> -</td> -<td width="0%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<p>The <small>CCITT</small> Group 3 and Group 4 compression -algorithms can only be used with bilevel data.</p> -<!-- INDENTATION --> -<p>Group 3 compression can be specified together with -several T.4-specific options: <b>1d</b> for 1-dimensional -encoding, <b>2d</b> for 2-dimensional encoding, and -<b>fill</b> to force each encoded scanline to be zero-filled -so that the terminating EOL code lies on a byte boundary. -Group 3-specific options are specified by appending a -‘‘:’’-separated list to the -‘‘g3’’ option; e.g. <b>−c -g3:2d:fill</b> to get 2D-encoded data with byte-aligned EOL -codes.</p> -<!-- INDENTATION --> -<p><small>LZW</small> compression can be specified together -with a <i>predictor</i> value. A predictor value of 2 causes -each scanline of the output image to undergo horizontal -differencing before it is encoded; a value of 1 forces each -scanline to be encoded without differencing. LZW-specific -options are specified by appending a -‘‘:’’-separated list to the -‘‘lzw’’ option; e.g. <b>−c -lzw:2</b> for <small>LZW</small> compression with horizontal -differencing.</p> -</td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−f</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the bit fill order to use in writing output -data. By default, <i>tiffdither</i> will create a new file -with the same fill order as the original. Specifying -<b>−f lsb2msb</b> will force data to be written with -the <i>FillOrder</i> tag set to <small>LSB2MSB ,</small> -while <b>−f msb2lsb</b> will force data to be written -with the <i>Fill- Order</i> tag set to <small>MSB2LSB -.</small></p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−t</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Set the threshold value for dithering. By default the -threshold value is 128.</p> -</td> -<td width="0%"> -</td> -</table> -<a name="NOTES"></a> -<h2>NOTES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The dither algorithm is taken from the -<b>tiffmedian</b>(1) program (written by Paul Heckbert).</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>pal2rgb</b>(1), <b>fax2tiff</b>(1), -<b>tiffinfo</b>(1), <b>tiffcp</b>(1), <b>tiff2bw</b>(1), -<b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/tiffdump.1.html b/src/3rdparty/libtiff/html/man/tiffdump.1.html deleted file mode 100644 index abf0662c..0000000 --- a/src/3rdparty/libtiff/html/man/tiffdump.1.html +++ /dev/null @@ -1,145 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:20 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFDUMP</title> -</head> -<body> - -<h1 align=center>TIFFDUMP</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>tiffdump − print verbatim information about -<small>TIFF</small> files</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiffdump</b> [ <i>options</i> ] <i>name ...</i></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>tiffdump</i> displays directory information from files -created according to the Tag Image File Format, Revision -6.0. The header of each <small>TIFF</small> file (magic -number, version, and first directory offset) is displayed, -followed by the tag contents of each directory in the file. -For each tag, the name, data type, count, and value(s) is -displayed. When the symbolic name for a tag or data type is -known, the symbolic name is displayed followed by it’s -numeric (decimal) value. Tag values are displayed enclosed -in ‘‘<>’’ characters -immediately preceded by the value of the count field. For -example, an <i>ImageWidth</i> tag might be displayed as -‘‘ImageWidth (256) SHORT (3) -1<800>’’.</p> -<!-- INDENTATION --> -<p><i>tiffdump</i> is particularly useful for investigating -the contents of <small>TIFF</small> files that -<i>libtiff</i> does not understand.</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="2%"> - -<p><b>−h</b></p> -</td> -<td width="6%"></td> -<td width="80%"> - -<p>Force numeric data to be printed in hexadecimal rather -than the default decimal.</p> -</td> -<td width="0%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−m</b> <i>items</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>Change the number of indirect data items that are -printed. By default, this will be 24.</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−o</b> <i>offset</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>Dump the contents of the <small>IFD</small> at the a -particular file offset. The file offset may be specified -using the usual C-style syntax; i.e. a leading -‘‘0x’’ for hexadecimal and a leading -‘‘0’’ for octal.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiffinfo</b>(1), <b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/tiffgt.1.html b/src/3rdparty/libtiff/html/man/tiffgt.1.html deleted file mode 100644 index e8bd4b2..0000000 --- a/src/3rdparty/libtiff/html/man/tiffgt.1.html +++ /dev/null @@ -1,551 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:20 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFGT</title> -</head> -<body> - -<h1 align=center>TIFFGT</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#BUGS">BUGS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>tiffgt − display an image stored in a -<small>TIFF</small> file (Silicon Graphics version)</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiffgt</b> [ <i>options</i> ] <i>input.tif ...</i></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>tiffgt</i> displays one or more images stored using -the Tag Image File Format, Revision 6.0. Each image is -placed in a fixed size window that the user must position on -the display (unless configured otherwise through X -defaults). If the display has fewer than 24 bitplanes, or if -the image does not warrant full color, then -<small>RGB</small> color values are mapped to the closest -values that exist in the colormap (this is done using the -<i>rgbi</i> routine found in the graphics utility library -<b>−lgutil</b>.)</p> -<!-- INDENTATION --> -<p><i>tiffgt</i> correctly handles files with any of the -following characteristics:</p></td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="3" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="15%"></td> -<td width="34%"> - -<p><i>BitsPerSample</i></p> -</td> -<td width="50%"> - -<p>1, 2, 4, 8, 16</p> -</td> -<tr valign="top" align="left"> -<td width="15%"></td> -<td width="34%"> - -<p><i>SamplesPerPixel</i></p> -</td> -<td width="50%"> - -<p>1, 3, 4 (the 4th sample is ignored)</p> -</td> -<tr valign="top" align="left"> -<td width="15%"></td> -<td width="34%"> - -<p><i>PhotometricInterpretation</i></p> -</td> -<td width="50%"> - -<p>0 (min-is-white), 1 (min-is-black), 2 (RGB), 3 -(palette), 6 (YCbCr)</p> -</td> -<tr valign="top" align="left"> -<td width="15%"></td> -<td width="34%"> - -<p><i>PlanarConfiguration</i></p> -</td> -<td width="50%"> - -<p>1 (contiguous), 2 (separate)</p> -</td> -<tr valign="top" align="left"> -<td width="15%"></td> -<td width="34%"> - -<p><i>Orientation</i></p> -</td> -<td width="50%"> - -<p>1 (top-left), 4 (bottom-left)</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Data may be organized as strips or tiles and may be -compressed with any of the compression algorithms supported -by the <i>libtiff</i>(3) library.</p> -<!-- INDENTATION --> -<p>For palette images (<i>PhotometricInterpretation</i>=3), -<i>tiffgt</i> inspects the colormap values and assumes -either 16-bit or 8-bit values according to the maximum -value. That is, if no colormap entry greater than 255 is -found, <i>tiffgt</i> assumes the colormap has only 8-bit -values; otherwise it assumes 16-bit values. This inspection -is done to handle old images written by previous (incorrect) -versions of <i>libtiff</i>.</p> -<!-- INDENTATION --> -<p><i>tiffgt</i> can be used to display multiple images -one-at-a-time. The left mouse button switches the display to -the first image in the <i>next</i> file in the list of files -specified on the command line. The right mouse button -switches to the first image in the <i>previous</i> file in -the list. The middle mouse button causes the first image in -the first file specified on the command line to be -displayed. In addition the following keyboard commands are -recognized:</p> -</td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="4" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="8%"> - -<p><b>b</b></p> -</td> -<td width="80%"> - -<p>Use a <i>PhotometricInterpretation</i> of MinIsBlack in -displaying the current image.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="8%"> - -<p><b>l</b></p> -</td> -<td width="80%"> - -<p>Use a <i>FillOrder</i> of lsb-to-msb in decoding the -current image.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="8%"> - -<p><b>m</b></p> -</td> -<td width="80%"> - -<p>Use a <i>FillOrder</i> of msb-to-lsb in decoding the -current image.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="8%"> - -<p><b>c</b></p> -</td> -<td width="80%"> - -<p>Use a colormap visual to display the current image.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="8%"> - -<p><b>r</b></p> -</td> -<td width="80%"> - -<p>Use a true color (24-bit RGB) visual to display the -current image.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="8%"> - -<p><b>w</b></p> -</td> -<td width="80%"> - -<p>Use a <i>PhotometricInterpretation</i> of MinIsWhite in -displaying the current image.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="8%"> - -<p><b>W</b></p> -</td> -<td width="80%"> - -<p>Toggle (enable/disable) display of warning messages from -the <small>TIFF</small> library when decoding images.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="8%"> - -<p><b>E</b></p> -</td> -<td width="80%"> - -<p>Toggle (enable/disable) display of error messages from -the <small>TIFF</small> library when decoding images.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="8%"> - -<p><b>z</b></p> -</td> -<td width="80%"> - -<p>Reset all parameters to their default settings -(<i>FillOrder</i>, <i>PhotometricInterpretation</i>, -handling of warnings and errors).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="8%"> - -<p><b>PageUp</b></p> -</td> -<td width="80%"> - -<p>Display the previous image in the current file or the -last image in the previous file.</p> -</td> -<td width="0%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>PageDown</b></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>Display the next image in the current file or the first -image in the next file.</p> -</td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="6%"> - -<p><b>Home</b></p> -</td> -<td width="2%"></td> -<td width="80%"> - -<p>Display the first image in the current file.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="6%"> - -<p><b>End</b></p> -</td> -<td width="2%"></td> -<td width="80%"> - -<p>Display the last image in the current file -(unimplemented).</p> -</td> -<td width="0%"> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−c</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force image display in a colormap window.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−d</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify an image to display by directory number. By -default the first image in the file is displayed. -Directories are numbered starting at zero.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−e</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Enable reporting of error messages from the -<small>TIFF</small> library. By default <i>tiffgt</i> -silently ignores images that cannot be read.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−f</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force <i>tiffgt</i> to run as a foreground process. By -default <i>tiffgt</i> will place itself in the background -once it has opened the requested image file.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−l</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force the presumed bit ordering to be <small>LSB</small> -to <small>MSB.</small></p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−m</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force the presumed bit ordering to be <small>MSB</small> -to <small>LSB.</small></p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−o</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify an image to display by directory offset. By -default the first image in the file is displayed. -Directories offsets may be specified using C-style syntax; -i.e. a leading ‘‘0x’’ for -hexadecimal and a leading ‘‘0’’ for -octal.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−p</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Override the value of the -<i>PhotometricInterpretation</i> tag; the parameter may be -one of: <b>miniswhite</b>, <b>minisblack</b>, <b>rgb</b>, -<b>palette</b>, <b>mask</b>, <b>separated</b>, <b>ycbcr</b>, -and <b>cielab</b>.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−r</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Force image display in a full color window.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−s</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Stop on the first read error. By default all errors in -the input data are ignored and <i>tiffgt</i> does it’s -best to display as much of an image as possible.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−w</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Enable reporting of warning messages from the -<small>TIFF</small> library. By default <i>tiffgt</i> -ignores warning messages generated when reading an -image.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−v</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Place information in the title bar describing what type -of window (full color or colormap) is being used, the name -of the input file, and the directory index of the image (if -non-zero). By default, the window type is not shown in the -title bar.</p> -</td> -<td width="0%"> -</td> -</table> -<a name="BUGS"></a> -<h2>BUGS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Images wider and taller than the display are silently -truncated to avoid crashing old versions of the window -manager.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiffdump</b>(1), <b>tiffinfo</b>(1), <b>tiffcp</b>(1), -<b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/tiffinfo.1.html b/src/3rdparty/libtiff/html/man/tiffinfo.1.html deleted file mode 100644 index 4863ed3..0000000 --- a/src/3rdparty/libtiff/html/man/tiffinfo.1.html +++ /dev/null @@ -1,196 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:20 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFINFO</title> -</head> -<body> - -<h1 align=center>TIFFINFO</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>tiffinfo − print information about -<small>TIFF</small> files</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiffinfo</b> [ <i>options</i> ] <i>input.tif -...</i></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>Tiffinfo</i> displays information about files created -according to the Tag Image File Format, Revision 6.0. By -default, the contents of each <small>TIFF</small> directory -in each file is displayed, with the value of each tag shown -symbolically (where sensible).</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−c</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Display the colormap and color/gray response curves, if -present.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−D</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>In addition to displaying the directory tags, read and -decompress all the data in each image (but not display -it).</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−d</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>In addition to displaying the directory tags, print each -byte of decompressed data in hexadecimal.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−j</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Display any <small>JPEG</small> -related tags that are -present.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−o</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Set the initial <small>TIFF</small> directory according -to the specified file offset. The file offset may be -specified using the usual C-style syntax; i.e. a leading -‘‘0x’’ for hexadecimal and a leading -‘‘0’’ for octal.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−s</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Display the offsets and byte counts for each data strip -in a directory.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−z</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Enable strip chopping when reading image data.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−#</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Set the initial <small>TIFF</small> directory to -<i>#</i>.</p> -</td> -<td width="0%"> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>pal2rgb</b>(1), <b>tiffcp</b>(1), <b>tiffcmp</b>(1), -<b>tiffmedian</b>(1), <b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/tiffmedian.1.html b/src/3rdparty/libtiff/html/man/tiffmedian.1.html deleted file mode 100644 index 5961317..0000000 --- a/src/3rdparty/libtiff/html/man/tiffmedian.1.html +++ /dev/null @@ -1,183 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:20 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFMEDIAN</title> -</head> -<body> - -<h1 align=center>TIFFMEDIAN</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#NOTES">NOTES</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>tiffmedian − apply the median cut algorithm to data -in a <small>TIFF</small> file</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiffmedian</b> [ <i>options</i> ] <i>input.tif -output.tif</i></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>tiffmedian</i> applies the median cut algorithm to an -<small>RGB</small> image in <i>input.tif</i> to generate a -palette image that is written to <i>output.tif</i>. The -generated colormap has, by default, 256 entries. The image -data is quantized by mapping each pixel to the closest color -values in the colormap.</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="11%"></td> -<td width="2%"> - -<p><b>−c</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the compression to use for data written to the -output file: <b>none</b> for no compression, <b>packbits</b> -for PackBits compression, <b>lzw</b> for Lempel-Ziv & -Welch compression, and <b>zip</b> for Deflate compression. -By default <i>tiffmedian</i> will compress data according to -the value of the <i>Compression</i> tag found in the source -file.</p> -</td> -<td width="0%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<p><small>LZW</small> compression can be specified together -with a <i>predictor</i> value. A predictor value of 2 causes -each scanline of the output image to undergo horizontal -differencing before it is encoded; a value of 1 forces each -scanline to be encoded without differencing. LZW-specific -options are specified by appending a -‘‘:’’-separated list to the -‘‘lzw’’ option; e.g. <b>−c -lzw:2</b> for <small>LZW</small> compression with horizontal -differencing.</p> -</td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="2%"> - -<p><b>−C</b></p> -</td> -<td width="6%"></td> -<td width="80%"> - -<p>Specify the number of entries to use in the generated -colormap. By default all 256 entries/colors are used.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="2%"> - -<p><b>−f</b></p> -</td> -<td width="6%"></td> -<td width="80%"> - -<p>Apply Floyd-Steinberg dithering before selecting a -colormap entry.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="2%"> - -<p><b>−r</b></p> -</td> -<td width="6%"></td> -<td width="80%"> - -<p>Specify the number of rows (scanlines) in each strip of -data written to the output file. By default, -<i>tiffmedian</i> attempts to set the rows/strip that no -more than 8 kilobytes of data appear in a strip.</p> -</td> -<td width="0%"> -</td> -</table> -<a name="NOTES"></a> -<h2>NOTES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>This program is derived from Paul Heckbert’s -<i>median</i> program.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>pal2rgb</b>(1), <b>tiffinfo</b>(1), <b>tiffcp</b>(1), -<b>tiffcmp</b>(1), <b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p><b>Color Image Quantization for Frame Buffer Display</b>, -Paul Heckbert, SIGGRAPH proceedings, 1982, pp. 297-307.</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/tiffset.1.html b/src/3rdparty/libtiff/html/man/tiffset.1.html deleted file mode 100644 index fb4d0ed..0000000 --- a/src/3rdparty/libtiff/html/man/tiffset.1.html +++ /dev/null @@ -1,176 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:20 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFSET</title> -</head> -<body> - -<h1 align=center>TIFFSET</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#EXAMPLES">EXAMPLES</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>tiffset − set a field in a <small>TIFF</small> -header</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiffset</b> [ <i>options</i> ] <i>filename.tif</i></p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>Tiffset</i> sets the value of a <small>TIFF</small> -header to a specified value.</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−s</b> <i>tagnumber</i> [ <i>count</i> ] -<i>value ...</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>Set the value of the named tag to the value or values -specified.</p> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>−sf</b> <i>tagnumber filename</i></p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="19%"></td> -<td width="80%"> -<p>Set the value of the tag to the contents of filename. -This option is supported for ASCII tags only.</p> -</td> -</table> -<a name="EXAMPLES"></a> -<h2>EXAMPLES</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The following example sets the image description tag -(270) of a.tif to the contents of the file descrip:</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>tiffset −sf 270 descrip a.tif -</pre> -</td> -</table> -<!-- INDENTATION --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>The following example sets the artist tag (315) of a.tif -to the string -‘‘Anonymous’’:</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>tiffset −s 305 Anonymous a.tif -</pre> -</td> -</table> -<!-- INDENTATION --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>This example sets the resolution of the file a.tif to 300 -dpi:</p></td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<pre>tiffset −s 296 2 a.tif -tiffset −s 282 300.0 a.tif -tiffset −s 283 300.0 a.tif -</pre> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> - -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiffdump</b>(1), <b>tiffinfo</b>(1), <b>tiffcp</b>(1), -<b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/tiffsplit.1.html b/src/3rdparty/libtiff/html/man/tiffsplit.1.html deleted file mode 100644 index adbc2f8..0000000 --- a/src/3rdparty/libtiff/html/man/tiffsplit.1.html +++ /dev/null @@ -1,102 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:20 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFSPLIT</title> -</head> -<body> - -<h1 align=center>TIFFSPLIT</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#BUGS">BUGS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>tiffsplit − split a multi-image <small>TIFF</small> -into single-image <small>TIFF</small> files</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiffsplit</b> <i>src.tif</i> [ <i>prefix</i> ]</p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>tiffsplit</i> takes a multi-directory (page) -<small>TIFF</small> file and creates one or more -single-directory (page) <small>TIFF</small> files from it. -The output files are given names created by concatenating a -prefix, a lexically ordered suffix in the range -[<i>aaa</i>-<i>zzz</i>], the suffix <i>.tif</i> (e.g. -<i>xaaa.tif</i>, <i>xaab.tif</i>, <i>xzzz.tif</i>). If a -prefix is not specified on the command line, the default -prefix of <i>x</i> is used.</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>None.</p> -</td> -</table> -<a name="BUGS"></a> -<h2>BUGS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Only a select set of ‘‘known -tags’’ is copied when splitting.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiffcp</b>(1), <b>tiffinfo</b>(1), -<b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/man/tiffsv.1.html b/src/3rdparty/libtiff/html/man/tiffsv.1.html deleted file mode 100644 index fb484b0..0000000 --- a/src/3rdparty/libtiff/html/man/tiffsv.1.html +++ /dev/null @@ -1,207 +0,0 @@ -<!-- Creator : groff version 1.18.1 --> -<!-- CreationDate: Fri Jul 13 17:43:20 2007 --> -<html> -<head> -<meta name="generator" content="groff -Thtml, see www.gnu.org"> -<meta name="Content-Style" content="text/css"> -<title>TIFFSV</title> -</head> -<body> - -<h1 align=center>TIFFSV</h1> -<a href="#NAME">NAME</a><br> -<a href="#SYNOPSIS">SYNOPSIS</a><br> -<a href="#DESCRIPTION">DESCRIPTION</a><br> -<a href="#OPTIONS">OPTIONS</a><br> -<a href="#NOTE">NOTE</a><br> -<a href="#BUGS">BUGS</a><br> -<a href="#SEE ALSO">SEE ALSO</a><br> - -<hr> -<a name="NAME"></a> -<h2>NAME</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>tiffsv − save an image from the framebuffer in a -<small>TIFF</small> file (Silicon Graphics version)</p> -</td> -</table> -<a name="SYNOPSIS"></a> -<h2>SYNOPSIS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>tiffsv</b> [ <i>options</i> ] <i>output.tif</i> [ -<i>x1 x2 y1 y2</i> ]</p> -</td> -</table> -<a name="DESCRIPTION"></a> -<h2>DESCRIPTION</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><i>tiffsv</i> saves all or part of the framebuffer in a -file using the Tag Image File Format, Revision 6.0. By -default, the image is saved with data samples packed -(<i>PlanarConfiguration</i>=1), compressed with the -Lempel-Ziv & Welch algorithm (<i>Compression</i>=5), and -with each strip no more than 8 kilobytes. These -characteristics can be overridden, or explicitly specified -with the options described below.</p> -</td> -</table> -<a name="OPTIONS"></a> -<h2>OPTIONS</h2> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−b</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Save the image as a greyscale image as if it were -processed by <i>tiff2bw</i>(1). This option is included for -compatibility with the standard <i>scrsave</i>(6D) -program.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−c</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the compression to use for data written to the -output file: <b>none</b> for no compression, <b>packbits</b> -for PackBits compression, <b>jpeg</b> for baseline JPEG -compression, <b>zip</b> for Deflate compression, and -<b>lzw</b> for Lempel-Ziv & Welch compression -(default).</p> -</td> -<td width="0%"> -</td> -</table> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="17%"></td> -<td width="82%"> -<p><small>LZW</small> compression can be specified together -with a <i>predictor</i> value. A predictor value of 2 causes -each scanline of the output image to undergo horizontal -differencing before it is encoded; a value of 1 forces each -scanline to be encoded without differencing. LZW-specific -options are specified by appending a -‘‘:’’-separated list to the -‘‘lzw’’ option; e.g. <b>−c -lzw:2</b> for <small>LZW</small> compression with horizontal -differencing.</p> -</td> -</table> -<!-- TABS --> -<table width="100%" border=0 rules="none" frame="void" - cols="5" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−p</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the planar configuration to use in writing image -data. By default, <i>tiffsv</i> will create a new file with -the data samples packed contiguously. Specifying <b>−p -contig</b> will force data to be written with multi-sample -data packed together, while <b>−p separate</b> will -force samples to be written in separate planes.</p> -</td> -<td width="0%"> -</td> -<tr valign="top" align="left"> -<td width="10%"></td> -<td width="3%"> - -<p><b>−r</b></p> -</td> -<td width="5%"></td> -<td width="80%"> - -<p>Specify the number of rows (scanlines) in each strip of -data written to the output file. By default, <i>tiffsv</i> -attempts to set the rows/strip that no more than 8 kilobytes -of data appear in a strip.</p> -</td> -<td width="0%"> -</td> -</table> -<a name="NOTE"></a> -<h2>NOTE</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>Except for the use of <small>TIFF,</small> this program -is equivalent to the standard <i>scrsave</i> program. This -means, for example, that you can use it in conjunction with -the standard <i>icut</i> program simply by creating a link -called <i>scrsave</i>, or by creating a shell script called -<i>scrsave</i> that invokes <i>tiffgt</i> with the -appropriate options.</p> -</td> -</table> -<a name="BUGS"></a> -<h2>BUGS</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p>If data are saved compressed and in separate planes, then -the rows in each strip is silently set to one to avoid -limitations in the <b>libtiff</b>(3TIFF) library.</p> -</td> -</table> -<a name="SEE ALSO"></a> -<h2>SEE ALSO</h2> -<!-- INDENTATION --> -<table width="100%" border=0 rules="none" frame="void" - cols="2" cellspacing="0" cellpadding="0"> -<tr valign="top" align="left"> -<td width="8%"></td> -<td width="91%"> -<p><b>scrsave</b>(6D) <b>pal2rgb</b>(1), <b>tiffdump</b>(1), -<b>tiffgt</b>(1), <b>tiffinfo</b>(1), <b>tiffcp</b>(1), -<b>tiffmedian</b>(1), <b>libtiff</b>(3TIFF)</p> -<!-- INDENTATION --> -<p>Libtiff library home page: -<b>http://www.remotesensing.org/libtiff/</b></p> -</td> -</table> -<hr> -</body> -</html> diff --git a/src/3rdparty/libtiff/html/misc.html b/src/3rdparty/libtiff/html/misc.html deleted file mode 100644 index aed91a9..0000000 --- a/src/3rdparty/libtiff/html/misc.html +++ /dev/null @@ -1,116 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Acknowledgments and Other Issues -</TITLE> -</HEAD> -<BODY BGCOLOR=white> -<FONT FACE="Arial, Helvetica, Sans"> -<H1> -<IMG SRC=images/ring.gif WIDTH=124 HEIGHT=124 ALIGN=left BORDER=1 HSPACE=6> -Acknowledgments and Other Issues -</H1> - -<P> -Silicon Graphics has seen fit to allow us to give this work away. It -is free. There is no support or guarantee of any sort as to its -operations, correctness, or whatever. If you do anything useful with -all or parts of it you need to honor the copyright notices. It would -also be nice to be acknowledged.<p> - -<BR CLEAR=left> - -<H2>Acknowledgements</H2> - -The libtiff software was written by Sam Leffler while working for -Silicon Graphics.<p> - -The LZW algorithm is derived from the compress program (the proper attribution -is included in the source code). The Group 3 fax stuff originated as code -from Jef Poskanzer, but has since been rewritten several times. The latest -version uses an algorithm from Frank Cringle -- consult -<TT>libtiff/mkg3states.c</TT> and <TT>libtiff/tif_fax3.h</TT> for further -information. The JPEG support was written by Tom Lane and is dependent on the -excellent work of Tom Lane and the Independent JPEG Group (IJG) who distribute -their work under friendly licensing similar to this software. Joris Van Damme -implemented the robust Old JPEG decoder (as included in libtiff since version -3.9.0, there was another Old JPEG module in older releases, which was -incomplete and unsuitable for many existing images of that format). JBIG -module was written by Lee Howard and depends on JBIG library from the Markus -Kuhn. Many other people have by now helped with bug fixes and code; a few of -the more persistent contributors have been: - -<PRE> - Bjorn P. Brox - Dan McCoy - J.T. Conklin - Richard Minner - Frank D. Cringle - Richard Mlynarik - Soren Pingel Dalsgaard - Niles Ritter - Steve Johnson - Karsten Spang - Tom Lane - Peter Smith - Brent Roman - Mike Welles - Frank Warmerdam - Greg Ward - Stanislav Brabec - Roman Shpount - Peter Skarpetis - Arvan Pritchard - Bernt Herd - Joseph Orost - Phil Beffery - Ivo Penzar - Francois Dagand - Albert Chin-A-Young - Bruce A. Mallett - Dwight Kelly - Andrey Kiselev - Ross Finlayson - Dmitry V. Levin - Bob Friesenhahn - Lee Howard - Joris Van Damme - Tavis Ormandy - Richard Nolde -</PRE> - -(my apology to anyone that was inadvertently not listed.) - -<H2>Use and Copyright</H2> - -<P><H5><PRE> -Copyright (c) 1988-1997 Sam Leffler -Copyright (c) 1991-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. -</PRE></H5> - -<P> -<HR> - - -Last updated: $Date: 2007/02/24 15:47:04 $ -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/support.html b/src/3rdparty/libtiff/html/support.html deleted file mode 100644 index f6f5d60..0000000 --- a/src/3rdparty/libtiff/html/support.html +++ /dev/null @@ -1,655 +0,0 @@ -<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html lang="en"> -<head> - <title>TIFF 6.0 Specification Coverage</title> - <meta http-equiv="content-type" content="text/html; charset=ISO-8859-1"> - <meta http-equiv="content-language" content="en"> - <style type="text/css"> - <!-- - th {text-align: left; vertical-align: top; font-style: italic; font-weight: normal} - --> - </style> -</head> -<body lang="en" text="#000000" bgcolor="#ffffff" link="#0000ff" alink="#0000ff" vlink="#0000ff"> - <table border="0" cellspacing="0" cellpadding="0"> - <tr> - <td style="padding-left: 1em; padding-right: 1em"><img src="images/strike.gif" width="128" height="100" alt=""></td> - <td> - <h1>TIFF 6.0 Specification Coverage</h1> - <p> - The library is capable of dealing with images that are written to - follow the 5.0 or 6.0 TIFF spec. There is also considerable support - for some of the more esoteric portions of the 6.0 TIFF spec. - </p> - </td> - </tr> - </table> - <br> - <table border="1" cellspacing="0" cellpadding="5"> - <tr> - <th>Core requirements</th> - <td> - <p> - Both <tt>"MM"</tt> and <tt>"II"</tt> byte orders are handled. - Both packed and separated planar configuration of samples. - Any number of samples per pixel (memory permitting). - Any image width and height (memory permitting). - Multiple subfiles can be read and written. - Editing is <b>not</b> supported in that related subfiles (e.g. - a reduced resolution version of an image) are not automatically - updated. - </p> - <p> - Tags handled: <tt>ExtraSamples</tt>, <tt>ImageWidth</tt>, - <tt>ImageLength</tt>, <tt>NewSubfileType</tt>, <tt>ResolutionUnit</tt>. - <tt>Rowsperstrip</tt>, <tt>StripOffsets</tt>, <tt>StripByteCounts</tt>, - <tt>XResolution</tt>, <tt>YResolution</tt> - </p> - </td> - </tr> - <tr> - <th>Tiled Images</th> - <td><tt>TileWidth</tt>, <tt>TileLength</tt>, <tt>TileOffsets</tt>, - <tt>TileByteCounts</tt></td> - </tr> - <tr> - <th>Image Colorimetry Information</th> - <td><tt>WhitePoint</tt>, <tt>PrimaryChromaticities</tt>, <tt>TransferFunction</tt>, - <tt>ReferenceBlackWhite</tt></td> - </tr> - <tr> - <th>Class B for bilevel images</th> - <td><tt>SamplesPerPixel</tt> = 1<br> - <tt>BitsPerSample</tt> = 1<br> - <tt>Compression</tt> = 1 (none), 2 (CCITT 1D), or 32773 (PackBits)<br> - <tt>PhotometricInterpretation</tt> = 0 (Min-is-White), 1 (Min-is-Black)</td> - </tr> - <tr> - <th>Class G for grayscale images</th> - <td><tt>SamplesPerPixel</tt> = 1<br> - <tt>BitsPerSample</tt> = 4, 8<br> - <tt>Compression</tt> = 1 (none) 5 (LZW)<br> - <tt>PhotometricInterpretation</tt> = 0 (Min-is-White), 1 (Min-is-Black)</td> - </tr> - <tr> - <th>Class P for palette color images</th> - <td><tt>SamplesPerPixel</tt> = 1<br> - <tt>BitsPerSample</tt> = 1-8<br> - <tt>Compression</tt> = 1 (none) 5 (LZW)<br> - <tt>PhotometricInterpretation</tt> = 3 (Palette RGB)<br> - <tt>ColorMap</tt></td> - </tr> - <tr> - <th>Class R for RGB full color images</th> - <td><tt>SamplesPerPixel</tt> = 3<br> - <tt>BitsPerSample</tt> = <8,8,8><br> - <tt>PlanarConfiguration</tt> = 1, 2<br> - <tt>Compression</tt> = 1 (none) 5 (LZW)<br> - <tt>PhotometricInterpretation</tt> = 2 (RGB)</td> - </tr> - <tr> - <th>Class F for facsimile</th> - <td>(<i>Class B tags plus...</i>)<br> - <tt>Compression</tt> = 3 (CCITT Group 3), 4 (CCITT Group 4)<br> - <tt>FillOrder</tt> = 1 (MSB), 2 (LSB)<br> - <tt>Group3Options</tt> = 1 (2d encoding), 4 (zero fill), 5 (2d+fill)<br> - <tt>ImageWidth</tt> = 1728, 2048, 2482<br> - <tt>NewSubFileType</tt> = 2<br> - <tt>ResolutionUnit</tt> = 2 (Inch), 3 (Centimeter)<br> - <tt>PageNumber</tt>, - <tt>XResolution</tt>, - <tt>YResolution</tt>, - <tt>Software</tt>, - <tt>BadFaxLines</tt>, - <tt>CleanFaxData</tt>, - <tt>ConsecutiveBadFaxLines</tt>, - <tt>DateTime</tt>, - <tt>DocumentName</tt>, - <tt>ImageDescription</tt>, - <tt>Orientation</tt></td> - </tr> - <tr> - <th>Class S for separated images</th> - <td><tt>SamplesPerPixel</tt> = 4<br> - <tt>PlanarConfiguration</tt> = 1, 2<br> - <tt>Compression</tt> = 1 (none), 5 (LZW)<br> - <tt>PhotometricInterpretation</tt> = 5 (Separated)<br> - <tt>InkSet</tt> = 1 (CMYK)<br> - <tt>DotRange</tt>, - <tt>InkNames</tt>, - <tt>DotRange</tt>, - <tt>TargetPrinter</tt></td> - </tr> - <tr> - <th>Class Y for YCbCr images</th> - <td><tt>SamplesPerPixel</tt> = 3<br> - <tt>BitsPerSample</tt> = <8,8,8><br> - <tt>PlanarConfiguration</tt> = 1, 2<br> - <tt>Compression</tt> = 1 (none), 5 (LZW), 7 (JPEG)<br> - <tt>PhotometricInterpretation</tt> = 6 (YCbCr)<br> - <tt>YCbCrCoefficients</tt>, - <tt>YCbCrSubsampling</tt>, - <tt>YCbCrPositioning</tt><br> - (<i>colorimetry info from Appendix H; see above</i>)</td> - </tr> - <tr> - <th>Class "JPEG" for JPEG images (per TTN2)</th> - <td><tt>PhotometricInterpretation</tt> = 1 (grayscale), 2 (RGB), 5 (CMYK), 6 (YCbCr)<br> - (<i>Class Y tags if YCbCr</i>)<br> - (<i>Class S tags if CMYK</i>)<br> - <tt>Compression</tt> = 7 (JPEG)</td> - </tr> - </table> - <p> - In addition, the library supports some optional compression algorithms - that are, in some cases, of dubious value. - </p> - <table border="0" cellspacing="0" cellpadding="2"> - <tr><th>Compression tag value</th><th>Compression algorithm</th></tr> - <tr><td>32766</td><td>NeXT 2-bit encoding</td></tr> - <tr><td>32809</td><td>ThunderScan 4-bit encoding</td></tr> - <tr><td>32909</td><td>Pixar companded 11-bit ZIP encoding</td></tr> - <tr><td>32946</td><td>PKZIP-style Deflate encoding (experimental)</td></tr> - <tr><td>34676</td><td>SGI 32-bit Log Luminance encoding (experimental)</td></tr> - <tr><td>34677</td><td>SGI 24-bit Log Luminance encoding (experimental)</td></tr> - </table> - <br> - <p> - Note that there is no support for the JPEG-related tags defined - in the 6.0 specification; the JPEG support is based on the post-6.0 - proposal given in TIFF Technical Note #2. - </p> - <table> - <tr> - <td valign=top><img src="images/info.gif" width="32" height="32" alt=""></td> - <td>For more information on the experimental Log Luminance encoding - consult the materials available at - <a href="http://www.anyhere.com/gward/pixformat/tiffluv.html">http://www.anyhere.com/gward/pixformat/tiffluv.html</a>.</td> - </tr> - </table> - <br> - <p> - The following table shows the tags that are recognized - and how they are used by the library. If no use is indicated, - then the library reads and writes the tag, but does not use it internally. - </p> - <table border="1" cellspacing="0" cellpadding="5"> - <tr> - <th>Tag Name</th> - <th>Value</th> - <th>R/W</th> - <th>Library's Use (Comments)</th> - </tr> - <tr> - <td><tt>NewSubFileType</tt></td> - <td>254</td> - <td>R/W</td> - <td>none (called <tt>SubFileType</tt> in <tiff.h>)</td> - </tr> - <tr> - <td><tt>SubFileType</tt></td> - <td>255</td> - <td>R/W</td> - <td>none (called <tt>OSubFileType</tt> in <tiff.h>)</td> - </tr> - <tr> - <td><tt>ImageWidth</tt></td> - <td>256</td> - <td>R/W</td> - <td>lots</td> - </tr> - <tr> - <td><tt>ImageLength</tt></td> - <td>257</td> - <td>R/W</td> - <td>lots</td> - </tr> - <tr> - <td><tt>BitsPerSample</tt></td> - <td>258</td> - <td>R/W</td> - <td>lots</td> - </tr> - <tr> - <td><tt>Compression</tt></td> - <td>259</td> - <td>R/W</td> - <td>to select appropriate codec</td> - </tr> - <tr> - <td><tt>PhotometricInterpretation</tt></td> - <td>262</td> - <td>R/W</td> - <td>lots</td> - </tr> - <tr> - <td><tt>Thresholding</tt></td> - <td>263</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>CellWidth</tt></td> - <td>264</td> - <td> </td> - <td>parsed but ignored</td> - </tr> - <tr> - <td><tt>CellLength</tt></td> - <td>265</td> - <td> </td> - <td>parsed but ignored</td> - </tr> - <tr> - <td><tt>FillOrder</tt></td> - <td>266</td> - <td>R/W</td> - <td>control bit order</td> - </tr> - <tr> - <td><tt>DocumentName</tt></td> - <td>269</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>ImageDescription</tt></td> - <td>270</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>Make</tt></td> - <td>271</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>Model</tt></td> - <td>272</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>StripOffsets</tt></td> - <td>273</td> - <td>R/W</td> - <td>data i/o</td> - </tr> - <tr> - <td><tt>Orientation</tt></td> - <td>274</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>SamplesPerPixel</tt></td> - <td>277</td> - <td>R/W</td> - <td>lots</td> - </tr> - <tr> - <td><tt>RowsPerStrip</tt></td> - <td>278</td> - <td>R/W</td> - <td>data i/o</td> - </tr> - <tr> - <td><tt>StripByteCounts</tt></td> - <td>279</td> - <td>R/W</td> - <td>data i/o</td> - </tr> - <tr> - <td><tt>MinSampleValue</tt></td> - <td>280</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>MaxSampleValue</tt></td> - <td>281</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>XResolution</tt></td> - <td>282</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>YResolution</tt></td> - <td>283</td> - <td>R/W</td> - <td>used by Group 3 2d encoder</td> - </tr> - <tr> - <td><tt>PlanarConfiguration</tt></td> - <td>284</td> - <td>R/W</td> - <td>data i/o</td> - </tr> - <tr> - <td><tt>PageName</tt></td> - <td>285</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>XPosition</tt></td> - <td>286</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>YPosition</tt></td> - <td>286</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>FreeOffsets</tt></td> - <td>288</td> - <td> </td> - <td>parsed but ignored</td> - </tr> - <tr> - <td><tt>FreeByteCounts</tt></td> - <td>289</td> - <td> </td> - <td>parsed but ignored</td> - </tr> - <tr> - <td><tt>GrayResponseUnit</tt></td> - <td>290</td> - <td> </td> - <td>parsed but ignored</td> - </tr> - <tr> - <td><tt>GrayResponseCurve</tt></td> - <td>291</td> - <td> </td> - <td>parsed but ignored</td> - </tr> - <tr> - <td><tt>Group3Options</tt></td> - <td>292</td> - <td>R/W</td> - <td>used by Group 3 codec</td> - </tr> - <tr> - <td><tt>Group4Options</tt></td> - <td>293</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>ResolutionUnit</tt></td> - <td>296</td> - <td>R/W</td> - <td>used by Group 3 2d encoder</td> - </tr> - <tr> - <td><tt>PageNumber</tt></td> - <td>297</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>ColorResponseUnit</tt></td> - <td>300</td> - <td> </td> - <td>parsed but ignored</td> - </tr> - <tr> - <td><tt>TransferFunction</tt></td> - <td>301</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>Software</tt></td> - <td>305</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>DateTime</tt></td> - <td>306</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>Artist</tt></td> - <td>315</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>HostComputer</tt></td> - <td>316</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>Predictor</tt></td> - <td>317</td> - <td>R/W</td> - <td>used by LZW codec</td> - </tr> - <tr> - <td><tt>WhitePoint</tt></td> - <td>318</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>PrimaryChromacities</tt></td> - <td>319</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>ColorMap</tt></td> - <td>320</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>TileWidth</tt></td> - <td>322</td> - <td>R/W</td> - <td>data i/o</td> - </tr> - <tr> - <td><tt>TileLength</tt></td> - <td>323</td> - <td>R/W</td> - <td>data i/o</td> - </tr> - <tr> - <td><tt>TileOffsets</tt></td> - <td>324</td> - <td>R/W</td> - <td>data i/o</td> - </tr> - <tr> - <td><tt>TileByteCounts</tt></td> - <td>324</td> - <td>R/W</td> - <td>data i/o</td> - </tr> - <tr> - <td><tt>BadFaxLines</tt></td> - <td>326</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>CleanFaxData</tt></td> - <td>327</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>ConsecutiveBadFaxLines</tt></td> - <td>328</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>SubIFD</tt></td> - <td>330</td> - <td>R/W</td> - <td>subimage descriptor support</td> - </tr> - <tr> - <td><tt>InkSet</tt></td> - <td>332</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>InkNames</tt></td> - <td>333</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>DotRange</tt></td> - <td>336</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>TargetPrinter</tt></td> - <td>337</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>ExtraSamples</tt></td> - <td>338</td> - <td>R/W</td> - <td>lots</td> - </tr> - <tr> - <td><tt>SampleFormat</tt></td> - <td>339</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>SMinSampleValue</tt></td> - <td>340</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>SMaxSampleValue</tt></td> - <td>341</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>JPEGTables</tt></td> - <td>347</td> - <td>R/W</td> - <td>used by JPEG codec</td> - </tr> - <tr> - <td><tt>YCbCrCoefficients</tt></td> - <td>529</td> - <td>R/W</td> - <td>used by <tt>TIFFReadRGBAImage</tt> support</td> - </tr> - <tr> - <td><tt>YCbCrSubsampling</tt></td> - <td>530</td> - <td>R/W</td> - <td>tile/strip size calculations</td> - </tr> - <tr> - <td><tt>YCbCrPositioning</tt></td> - <td>531</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>ReferenceBlackWhite</tt></td> - <td>532</td> - <td>R/W</td> - <td> </td> - </tr> - <tr> - <td><tt>Matteing</tt></td> - <td>32995</td> - <td>R</td> - <td>none (obsoleted by <tt>ExtraSamples</tt> tag)</td> - </tr> - <tr> - <td><tt>DataType</tt></td> - <td>32996</td> - <td>R</td> - <td>none (obsoleted by <tt>SampleFormat</tt> tag)</td> - </tr> - <tr> - <td><tt>ImageDepth</tt></td> - <td>32997</td> - <td>R/W</td> - <td>tile/strip calculations</td> - </tr> - <tr> - <td><tt>TileDepth</tt></td> - <td>32998</td> - <td>R/W</td> - <td>tile/strip calculations</td> - </tr> - <tr> - <td><tt>StoNits</tt></td> - <td>37439</td> - <td>R/W</td> - <td> </td> - </tr> - </table> - <p> - The <tt>Matteing</tt> and <tt>DataType</tt> - tags have been obsoleted by the 6.0 - <tt>ExtraSamples</tt> and <tt>SampleFormat</tt> tags. - Consult the documentation on the - <tt>ExtraSamples</tt> tag and Associated Alpha for elaboration. Note however - that if you use Associated Alpha, you are expected to save data that is - pre-multipled by Alpha. If this means nothing to you, check out - Porter & Duff's paper in the '84 SIGGRAPH proceedings: "Compositing Digital - Images". - </p> - <p> - The <tt>ImageDepth</tt> - tag is a non-standard, but registered tag that specifies - the Z-dimension of volumetric data. The combination of <tt>ImageWidth</tt>, - <tt>ImageLength</tt>, and <tt>ImageDepth</tt>, - defines a 3D volume of pixels that are - further specified by <tt>BitsPerSample</tt> and - <tt>SamplesPerPixel</tt>. The <tt>TileDepth</tt> - tag (also non-standard, but registered) can be used to specified a - subvolume "tiling" of a volume of data. - </p> - <p> - The Colorimetry, and CMYK tags are additions that appear in TIFF 6.0. - Consult the TIFF 6.0 specification included in the <b>doc</b> directory - and <a href="document.html">online</a>. - </p> - <p> - The JPEG-related tag is specified in - <a href="TIFFTechNote2.html">TIFF Technical Note #2</a> which defines - a revised JPEG-in-TIFF scheme (revised over that appendix that was - part of the TIFF 6.0 specification). - </p> - <hr> - <p> - Last updated: $Date: 2005/12/28 06:53:18 $ - </p> -</body> -</html> - diff --git a/src/3rdparty/libtiff/html/tools.html b/src/3rdparty/libtiff/html/tools.html deleted file mode 100644 index b1a757e..0000000 --- a/src/3rdparty/libtiff/html/tools.html +++ /dev/null @@ -1,164 +0,0 @@ -<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html> -<head> -<meta name="generator" content= -"HTML Tidy for Solaris (vers 12 April 2005), see www.w3.org"> -<title>TIFF Tools Overview</title> -</head> -<body bgcolor="white"> -<h1><font face="Arial, Helvetica, Sans"><img src="images/quad.jpg" -width="144" height="108" align="left" border="1" hspace="6"> TIFF -Tools Overview</font></h1> -<p>This software distribution comes with a small collection of -programs for converting non-TIFF format images to TIFF and for -manipulating and interrogating the contents of TIFF images. Several -of these tools are useful in their own right. Many of them however -are more intended to serve as programming examples for using the -TIFF library.</p> -<h3>Device-dependent Programs</h3> -There are two device-dependent programs that serve as simple -examples for writing programs to display and save TIFF images. -<table border cellpadding="3"> -<tr> -<td valign="top" width="10%"> -<tt><a href="man/tiffgt.1.html">tiffgt</a> </tt></td> -<td>Display the contents of one or more TIFF images using OpenGL. -The software makes extensive use of the <tt>TIFFRGBAImage</tt> -facilities described elsewhere.</td> -</tr> -<tr> -<td valign="top" width="10%"><tt><a href="man/tiffsv.1.html">tiffsv</a></tt></td> -<td>A program to save all or part of a screen dump on a Silicon -Graphics system. As for <tt>tiffgt</tt> this code, while written to -use the IRIS GL, can be easily tailored to other devices.</td> -</tr> -</table> -<h3>Device-independent Programs</h3> -The remaining programs should be device-independent: -<table border cellpadding="3"> -<tr> -<td valign="top" width="10%"><tt><a href="man/bmp2tiff.1.html">bmp2tiff</a></tt></td> -<td>Convert BMP images to TIFF</td> -</tr> -<tr> -<td valign="top" width="10%"><tt><a href="man/fax2ps.1.html">fax2ps</a></tt></td> -<td>Convert a Group 3- or Group 4- compressed TIFF to PostScript -that is significantly more compressed than is generated by -<tt>tiff2ps</tt> (unless <tt>tiff2ps</tt> writes PS Level II)</td> -</tr> -<tr> -<td valign="top" width="10%"><tt><a href="man/fax2tiff.1.html">fax2tiff</a></tt></td> -<td>Convert raw Group 3 or Group 4 facsimile data to TIFF</td> -</tr> -<tr> -<td valign="top" width="10%"><tt><a href="man/gif2tiff.1.html">gif2tiff</a></tt></td> -<td>A quick hack that converts GIF 87a (old) format images to TIFF</td> -</tr> -<tr> -<td valign="top" width="10%"><tt><a href="man/pal2rgb.1.html">pal2rgb</a></tt></td> -<td>Convert a Palette-style image to a full color RGB image by -applying the colormap</td> -</tr> -<tr> -<td valign="top" width="10%"><tt><a href="man/ppm2tiff.1.html">ppm2tiff</a></tt></td> -<td>A quick hack that converts 8-bit PPM format images to TIFF</td> -</tr> -<tr> -<td valign="top" width="10%"><tt><a href="man/ras2tiff.1.html">ras2tiff</a></tt></td> -<td>A quick hack that converts Sun rasterfile format images to TIFF --- it's less than complete</td> -</tr> -<tr> -<td valign="top" width="10%"><tt><a href="man/raw2tiff.1.html">raw2tiff</a></tt></td> -<td>Create a TIFF file from raw data</td> -</tr> -<tr> -<td valign="top" width="10%"><tt><a href="man/rgb2ycbcr.1.html">rgb2ycbcr</a></tt></td> -<td>Convert an RGB, grayscale, or bilevel TIFF image to a YCbCr -TIFF image; it's mainly provided for testing</td> -</tr> -<tr> -<td valign="top" width="10%"><tt><a href="man/sgi2tiff.1.html">sgi2tiff</a></tt></td> -<td>A program to convert SGI image files to TIFF. This program is -only useful on SGI machines as it uses <tt>-limage</tt>.</td> -</tr> -<tr> -<td valign="top" width="10%"><tt><a href="man/thumbnail.1.html">thumbnail</a></tt></tt></td> -<td>Copy a bilevel TIFF to one that includes 8-bit greyscale -"thumbnail images" for each page; it is provided as an example of -how one might use the <tt>SubIFD</tt> tag (and the library support -for it)</td> -</tr> -<tr> -<td valign="top" width="10%"><tt><a href="man/tiff2bw.1.html">tiff2bw</a></tt></td> -<td>A simple program to convert a color image to grayscale</td> -</tr> -<tr> -<td valign="top" width="10%"><tt><a href="man/tiff2pdf.1.html">tiff2pdf</a></tt></td> -<td>Convert TIFF images to PDF</td> -</tr> -<tr> -<td valign="top" width="10%"><tt><a href="man/tiff2ps.1.html">tiff2ps</a></tt></td> -<td>Convert TIFF images to PostScript</td> -</tr> -<tr> -<td valign="top" width="10%"><tt><a href="man/tiff2rgba.1.html">tiff2rgba</a></tt></td> -<td>Convert a TIFF image to RGBA color space</td> -</tr> -<tr> -<td valign="top" width="10%"><tt><a href="man/tiffcmp.1.html">tiffcmp</a></tt></td> -<td>Compare the contents of two TIFF files (it does not check all -the directory information, but does check all the data)</td> -</tr> -<tr> -<td valign="top" width="10%"><tt><a href="man/tiffcp.1.html">tiffcp</a></tt></td> -<td>Copy, concatenate, and convert TIFF images (e.g. switching from -Compression=5 to Compression=1)</td> -</tr> -<tr> -<td valign="top" width="10%"><tt><a href="man/tiffcrop.1.html">tiffcrop</a></tt></td> -<td>Provides selection of images from within one or more multi-image -TIFF files, with orthogonal rotation, mirroring, cropping, and -extraction of multiple sections and exporting to one or more files. -It extends the functionality of tiffcp to support additional bit -depths in strips and tiles and enhances the selection capabilities of -tiffsplit. Bilevel images can be inverted and images may be split into -segments to fit on multiple /pages/ (standard paper sizes), plus other -functions described in the tiffcrop man page</td> -</tr> -<tr> -<td valign="top" width="10%"><tt><a href="man/tiffdither.1.html">tiffdither</a></tt></td> -<td>Dither a b&w image into a bilevel image (suitable for use -in creating fax files)</td> -</tr> -<tr> -<td valign="top" width="10%"><tt><a href="man/tiffdump.1.html">tiffdump</a></tt></td> -<td>Display the verbatim contents of the TIFF directory in a file -(it's very useful for debugging bogus files that you may get from -someone that claims they support TIFF)</td> -</tr> -<tr> -<td valign="top" width="10%"><tt><a href="man/tiffinfo.1.html">tiffinfo</a></tt></td> -<td>Display information about one or more TIFF files.</td> -</tr> -<tr> -<td valign="top" width="10%"><tt><a href="man/tiffmedian.1.html">tiffmedian</a></tt></td> -<td>A version of Paul Heckbert's median cut program that reads an -RGB TIFF image, and creates a TIFF palette file as a result</td> -</tr> -<tr> -<td valign="top" width="10%"><tt><a href="man/tiffset.1.html">tiffset</a></tt></td> -<td>Set a field in a TIFF header</td> -</tr> -<tr> -<td valign="top" width="10%"><tt><a href="man/tiffsplit.1.html">tiffsplit</a></tt></td> -<td>Create one or more single-image files from a (possibly) -multi-image file</td> -</tr> -</table> -<p>Check out the manual pages for details about the above -programs.</p> -<hr> -Last updated: $Date: 2009-10-28 22:13:58 $ -</body> -</html> diff --git a/src/3rdparty/libtiff/html/v3.4beta007.html b/src/3rdparty/libtiff/html/v3.4beta007.html deleted file mode 100644 index c535d27..0000000 --- a/src/3rdparty/libtiff/html/v3.4beta007.html +++ /dev/null @@ -1,112 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Changes in TIFF v3.4beta007 -</TITLE> -</HEAD> - -<BODY> -<FONT FACE="Arial, Helvetica, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.4beta007<BR> -<B>Previous Version</B>: v3.4beta004<BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.sgi.com/graphics/tiff">ftp.sgi.com (192.48.153.1), directory graphics/tiff</A><BR> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#port">Changes in the portability support</A> -<LI><A HREF="#tools">Changes in the tools</A> -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> -<LI>bit order was corrected for Pentium systems -<LI>a new define, <TT>HOST_BIGENDIAN</TT>, was added for code that - wants to statically use information about native cpu byte order -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> -<LI>the G3/G4 decoder was replaced by a new one that is faster and - has smaller state tables -<LI>Niles Ritter's client tag extension hooks were added -<LI>a new routine <TT>TIFFCurrentDirOffset</TT> was added for - applications that want to find out the file offset of a TIFF directory -<LI>the calculation of the number of strips in an image was corected - for images with certain esoteric configurations -<LI>a potential memory leak (very unlikely) was plugged -<LI>the <TT>TIFFReadRGBAImage</TT> support was completely rewritten - and new, more flexible support was added for reading images into - a fixed-format raster -<LI>YCbCr to RGB conversion done in the <TT>TIFFReadRGBAImage</TT> support - was optimized -<LI>a bug in JPEG support calculation of strip size was corrected -<LI>the LZW decoder was changed to initialize the code table to zero - to lessen potential problems that arise when invalid data is decoded -<LI><B>tiffcomp.h</B> is now aware of OS/2 -<LI>some function prototypes in <B>tiffio.h</B> and <B>tiffiop.h</B> - that contained parameter - names have been changed to avoid complaints from certain compilers -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="port"><B><FONT SIZE=+3>C</FONT>HANGES IN THE PORTABILITY SUPPORT:</B></A> - -<UL> -<LI><B>Makefile.in</B> has been corrected to use the parameters - chosen by the configure script -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> -<LI><TT>fax2ps</TT> has been rewritten and moved over from the user - contributed software -<LI>an uninitialized variable in <TT>pal2rgb</TT> has been fixed -<LI><TT>ras2tiff</TT> now converts 24-bit RGB raster data so that - samples are written in the proper order -<LI><TT>tiff2ps</TT> has been updated to include fixes - and enhancements from Alberto Accomazzi -<LI><TT>tiffcp</TT> now has a <TT>-o</TT> option to select a directory - by file offset -<LI><TT>tiffinfo</TT> is now capable of displaying the raw undecoded - image data in a file -<LI><TT>tiffgt</TT> has been rewritten to use the new <TT>TIFFRGBAImage</TT> - support and to handle multiple files -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -<ADDRESS> -<A HREF="sam.html">Sam Leffler</A> / <A HREF="mailto:sam@engr.sgi.com">sam@engr.sgi.com</A> -Last updated $Date: 1999/08/09 20:21:21 $. -</ADDRESS> - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.4beta016.html b/src/3rdparty/libtiff/html/v3.4beta016.html deleted file mode 100644 index 22f185f..0000000 --- a/src/3rdparty/libtiff/html/v3.4beta016.html +++ /dev/null @@ -1,122 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Changes in TIFF v3.4beta016 -</TITLE> -</HEAD> - -<BODY> -<FONT FACE="Arial, Helvetica, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.4beta016<BR> -<B>Previous Version</B>: <A HREF=v3.4beta007.html>v3.4beta007</A><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.sgi.com/graphics/tiff">ftp.sgi.com (192.48.153.1), directory graphics/tiff</A><BR> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -<LI><A HREF="#man">Changes in the manual pages</A> -<LI><A HREF="#html">Changes in the documentation</A> -<LI><A HREF="#contrib">Changes in contributed software</A> -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> -<LI>support was added for configuring the Deflate codec -<LI>support was added for the HTML documentation -<LI>codecs that are not configured for inclusion in the library - are no longer compiled -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> -<LI>support was added for registering new codecs external to the library - and for overriding the codecs that are builtin to the library -<LI>emulation support for the old <TT>DataType</TT> tag was improved -<LI>suppport was added for the <TT>SMinSampleValue</TT> - and <TT>SMaxSampleValue</TT> tags -<LI>the library no longer ignores <TT>TileWidth</TT> and <TT>TileLength</TT> - tags whose values are not a multiple of 16 (per the spec); this - permits old, improperly written, images to be read -<LI>the support for the <TT>Predictor</TT> tag was placed in a reusable - module so that it can be shared by multiple codecs -<LI>experimental compression support was added for the Deflate algorithm - (using the freely available zlib package) -<LI>a new routine, <TT>TIFFWriteBufferSetup</TT> was added a la the - routine <TT>TIFFReadBufferSetup</TT> -<LI>the DSO version of the library is now statically linked with the - JPEG and Deflate libraries; this means applications that link against - the DSO do not also need to link against these ancillary libraries -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> -<LI>all the tools now use common code to process compress-oriented arguments -<LI><TT>tiffdump</TT> should now compile on a Macintosh with MPW -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="man"><B><FONT SIZE=+3>C</FONT>HANGES IN THE MANUAL PAGES:</B></A> - -<UL> -<LI>everything was updated -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="html"><B><FONT SIZE=+3>C</FONT>HANGES IN THE DOCUMENTATION:</B></A> - -<UL> -<LI>everything was updated -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="contrib"><B><FONT SIZE=+3>C</FONT>HANGES IN CONTRIBUTED SOFTWARE:</B></A> - -<UL> -<LI><B>contrib/dbs/xtiff</B> was made to compile -<LI><B>contrib/mac-mpw</B> is new support for compiling the software on - a Macintosh under MPW; consult <A HREF=build.html#Mac>the documentation</A> - for details -<LI><B>contrib/tags</B> is information on how to use the tag extenion - facilities; consult - <A HREF=../contrib/tags/README>contrib/tags/README</A> for details -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -<ADDRESS> -<A HREF="sam.html">Sam Leffler</A> / <A HREF="mailto:sam@engr.sgi.com">sam@engr.sgi.com</A> -Last updated $Date: 1999/08/09 20:21:21 $. -</ADDRESS> - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.4beta018.html b/src/3rdparty/libtiff/html/v3.4beta018.html deleted file mode 100644 index ac1877f..0000000 --- a/src/3rdparty/libtiff/html/v3.4beta018.html +++ /dev/null @@ -1,84 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Changes in TIFF v3.4beta018 -</TITLE> -</HEAD> - -<BODY> -<FONT FACE="Arial, Helvetica, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.4beta018<BR> -<B>Previous Version</B>: <A HREF=v3.4beta016.html>v3.4beta016</A><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.sgi.com/graphics/tiff">ftp.sgi.com (192.48.153.1), directory graphics/tiff</A><BR> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> -<LI>configure now recognizes IRIX 6.x systems -<LI>configure now uses <TT>ENVOPTS</TT> when searching for an ANSI - C compiler; this fixes a problem configuring the software under - HP/UX with the native C compiler -<LI>configure now correctly recognizes memory-mapped files are supported - under AIX -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> -<LI><TT>make install</TT> now properly installs the include files -<LI>some portability fixes from Bjorn Brox -<LI>the G3/G4 codec now warns about decoded rows that are longer than - the image/tile width -<LI>changes from Frank Cringle to make the library work with the - gcc-specific bounds checking software -<LI>miscellaneous fixes to <TT>TIFFPrintDirectory</TT> -<LI>bug fix to correct a problem where <TT>TIFFWriteRawStrip</TT> - could not be used to automatically grow an image's length -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> -<LI>fixes from Frank Cringle to update <TT>fax2tiff</TT> -<LI>portability fixes to <TT>tiff2bw</TT> and <TT>tiffcmp</TT> -<LI><TT>tiffdump</TT> now uses the byte swapping routines in the library -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -<ADDRESS> -<A HREF="sam.html">Sam Leffler</A> / <A HREF="mailto:sam@engr.sgi.com">sam@engr.sgi.com</A> -Last updated $Date: 1999/08/09 20:21:21 $. -</ADDRESS> - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.4beta024.html b/src/3rdparty/libtiff/html/v3.4beta024.html deleted file mode 100644 index 25a3347..0000000 --- a/src/3rdparty/libtiff/html/v3.4beta024.html +++ /dev/null @@ -1,139 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Changes in TIFF v3.4beta024 -</TITLE> -</HEAD> - -<BODY> -<FONT FACE="Arial, Helvetica, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.4beta024<BR> -<B>Previous Version</B>: <A HREF=v3.4beta018.html>v3.4beta018</A><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.sgi.com/graphics/tiff">ftp.sgi.com (192.48.153.1), directory graphics/tiff</A><BR> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -<LI><A HREF="#man">Changes in the manual pages</A> -<LI><A HREF="#contrib">Changes in the contributed software</A> -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> -<LI>It is now possible to setup the software to build only the - library; configure reconizes this is the intent when the - <B>VERSION</B>, <B>tiff.alpha</B>, and <B>tif_version.c</B> - files are in the local directory (i.e. ``.'') -<LI>configure no longer tries to setup HTML materials -<LI>include file directories needed in building the library are now - specified with a <TT>DIRS_LIBINC</TT> config parameter -<LI>configure no longer checks for alternate compilers if <TT>CC</TT> - is set; if the specified compiler is not found or is not appropriate - the configuration procedure aborts -<LI>the <B>port.h</B> file generated by configure is now used only by - the library and as such as have been moved to the <B>libtiff</B> - directory -<LI>there is beginning support for building DSO's on systems other than IRIX -<LI>configure now verifies the JPEG and zlib directory pathnames by - checking for well-known include files in these directories -<LI>configure no longer creates the <B>dist</B> directory needed only - on SGI machines (for building SGI binary distributions) -<LI>a bug was fixed whereby configure would incorrectly set - <TT>ENVOPTS</TT> when building the software with gcc under AIX -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> -<LI>two new typedefs were added to <B>tiff.h</TT>: <TT>int8</TT> - and <TT>uint8</TT> for signed and unsigned 8-bit quantities, - respectively; these are currently used only by - programs in the <B>tools</B> directory -<LI>the <TT>BadFaxLines</TT>, <TT>CleanFaxData</TT>, and - <TT>ConsecutiveBadFaxLines</B> tags are now supported with - Group 4 compression -<LI>byte order is now correctly identified on 64-bit machines -<LI>a bug was fixed in the PackBits decoder where input data would - appear short when a no-op run was present -<LI>a bug was fixed in calculations with very wide strips -<LI><TT>TIFFWriteEncodedStrip</TT> and <TT>TIFFWriteRawStrip</TT> - were extended to support dynamically growing the number of - strips in an image (must set <TT>ImageLength</TT> prior to - making calls though) -<LI><TT>TIFFDefaultTileSize</TT> now rounds tile width and height - up to a multiple of 16 pixels, as required by the TIFF 6.0 specification -<LI>the file <B>version.h</B> is now built by a new <B>mkversion</B> - program; this was done for portability to non-UNIX systems -<LI>support was added for the Acorn RISC OS (from Peter Greenham) -<LI>the builtin codec table is now made <TT>const</TT> when compiling - under VMS so that <B>libtiff</B> can be built as a shared library -<LI>support for the PowerPC Mac (from Ruedi Boesch) -<LI>support for Window NT/Window 95 (from Scott Wagner) -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> -<LI>the tools no longer include <B>port.h</B> -<LI>various portability fixes; mostly to eliminate implicit assumptions - about how long <TT>int32</TT> data types are -<LI>PostScript Level II additions to <TT>tiff2ps</TT> from Bjorn Brox -<LI><TT>sgi2tiff</TT> now handles RGBA images -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="man"><B><FONT SIZE=+3>C</FONT>HANGES IN THE MANUAL PAGES:</B></A> - -<UL> -<LI>the documentation has been updated to reflect the current state of - the software -<LI>some routines have been moved to different manual pages - to group like-routines together -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="contrib"><B><FONT SIZE=+3>C</FONT>HANGES IN THE CONTRIBUTED SOFTWARE:</B></A> - -<UL> -<LI>support was added for the Acorn RISC OS (from Peter Greenham) -<LI>support for Windows NT/Windows 95 contributed for a previous - version of this software was sort of incorporated (it's broken - right now) (from Scott Wagner) -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -<ADDRESS> -<A HREF="sam.html">Sam Leffler</A> / <A HREF="mailto:sam@engr.sgi.com">sam@engr.sgi.com</A> -Last updated $Date: 1999/08/09 20:21:21 $. -</ADDRESS> - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.4beta028.html b/src/3rdparty/libtiff/html/v3.4beta028.html deleted file mode 100644 index ff7ef69..0000000 --- a/src/3rdparty/libtiff/html/v3.4beta028.html +++ /dev/null @@ -1,146 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Changes in TIFF v3.4beta028 -</TITLE> -</HEAD> - -<BODY> -<FONT FACE="Arial, Helvetica, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.4beta028<BR> -<B>Previous Version</B>: <A HREF=v3.4beta024.html>v3.4beta024</A><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.sgi.com/graphics/tiff">ftp.sgi.com (192.48.153.1), directory graphics/tiff</A><BR> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -<LI><A HREF="#man">Changes in the manual pages</A> -<LI><A HREF="#contrib">Changes in the contributed software</A> -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> -<LI>a <TT>-noninteractive</TT> flag was added to configure to - control whether or not it prints and prompts for configuration information -<LI>various typos and fixes were made in configure for the the - library-only build support (this and other configure fixes from - Richard Mlynarik <A HREF=mailto:mly@adoc.xerox.com><mly@adoc.xerox.com></A>) -<LI>bugs were fixed in the handling of pathnames supplied for external - packages; e.g. <TT>DIR_JPEG</TT> -<LI>the handling of <TT>SETMAKE</TT> is now done properly -<LI>the default prototype function declaration for <TT>pow</TT> was corrected -<LI>a bug was fixed in <B>libtiff/Makefile.in</B> that caused installation - to fail on systems without DSO support -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> -<LI>Acorn RISC O/S support that was accidentally left out of the - left out of the previous distribution is present (from Peter Greenham) -<LI>complaints about unknown and/or unsupported codecs have been - delayed until they are invoked; this permits applications to open - images and look at tags even if the image data is compressed with - an unknown/unsupported compression scheme -<LI>bugs in handling unknown tags have been corrected; applications - that use multiple codecs, each with codec-specific tags, no longer - generate confusing error messages -<LI>a missing pseudo-tag definition in the CCITT G3 codec was fixed - (this problem caused core dumps in the <TT>tiffcp</TT> program) -<LI>pseudo-tags are now treated specially; they are always considered - to be set (i.e. they do not use bits in the <TT>FIELD_*</TT> bit-vectors). -<LI>the use of strip chopping can now be controlled on a per-file basis - through a mode parameter supplied when opening a file (``C'' to - enable strip chopping and ``c'' to disable) -<LI>two bugs were fixed in the writing of opposite-endian byte-order - files -<LI>support was added for three new fax-related tags registered to - SGI: FaxRecvParams, FaxRecvTime, and FaxSubAddress -<LI>the bit order of image data read and written can now be controlled - on a per-file basis through a mode parameter supplied when opening - a file (``B'' to force MSB2LSB bit order, ``L'' for LSB2MSB bit - order, and ``H'' for the bit order of the native CPU) -<LI>the byte order of image and tag data written to newly-created files - can now be controlled on a per-file basis through a mode parameter - supplied when openening a file (``b'' to force Big-Endian byte order - and ``l'' to force Little-Endian byte order) -<LI>the use memory-mapped files for images opened read-only can now - be controlled on a per-file basis through a mode parameter supplied - when opening a file (``M'' to enable use of memory-mapped files - and ``m'' to disable use) -<LI>the use of the <TT>WIN32</TT> define in <B>tiffiop.h</B> has - been replaced by <TT>__WIN32__</TT> -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> -<LI><TT>fax2ps</TT> now does a <TT>save</TT> and <TT>restore</TT> - around each page of PostScript; this fixes a problem with VM - overflow when printing a many-page document on some printers -<LI>a bug in the handling of 3-channel images by <TT>ras2tiff</TT> - was fixed -<LI><TT>tiffcp</TT> has new options to control the byte order of - newly created files: <B>-B</B> for Big-Endian byte order, <B>-L</B> - for Little-Endian byte order; a <B>-M</B> option to disable the - use of memory-mapped files, and a <B>-C</B> option to disable the - use of strip chopping -<LI>bugs were fixed in <TT>tiffcp</TT>'s handling of codec-specific tags -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="man"><B><FONT SIZE=+3>C</FONT>HANGES IN THE MANUAL PAGES:</B></A> - -<UL> -<LI>the <TT>TIFFOpen</TT> page has been updated to reflect the new - optional open mode parameters -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="contrib"><B><FONT SIZE=+3>C</FONT>HANGES IN THE CONTRIBUTED SOFTWARE:</B></A> - -<UL> -<LI><B>contrib/win95</B> contains information and code from Philippe Tenenhaus - <A HREF=mailto:100423.3705@compuserve.com><100423.3705@compuserve.com></A> - about using the software under Windows 95 -<LI><B>contrib/winnt</B> contains information and code from Dave Dyer - <A HREF=mailto:ddyer@triple-i.com><ddyer@triple-i.com></A> - about using the software under Windows NT -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -<ADDRESS> -<A HREF="sam.html">Sam Leffler</A> / <A HREF="mailto:sam@engr.sgi.com">sam@engr.sgi.com</A> -Last updated $Date: 1999/08/09 20:21:21 $. -</ADDRESS> - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.4beta029.html b/src/3rdparty/libtiff/html/v3.4beta029.html deleted file mode 100644 index f2a3d3f..0000000 --- a/src/3rdparty/libtiff/html/v3.4beta029.html +++ /dev/null @@ -1,86 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Changes in TIFF v3.4beta029 -</TITLE> -</HEAD> - -<BODY> -<FONT FACE="Arial, Helvetica, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.4beta029<BR> -<B>Previous Version</B>: <A HREF=v3.4beta028.html>v3.4beta028</A><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.sgi.com/graphics/tiff">ftp.sgi.com (192.48.153.1), directory graphics/tiff</A><BR> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#contrib">Changes in the contributed software</A> -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> -<LI><B>configure</B> now relativizes pathname references given in - <TT>-L</TT> options (as frequently specified when configuring - ancillary packages) -<LI>problems related to configuring the software on Ultrix 4.4 have - been corrected -<LI>the shell to use in Makefiles and scripts can now be set with the - <TT>SCRIPT_SH</TT> configuration parameter -<LI>comments in <B>config.site</B> now correctly indicate how to setup the - use of ancillary packages -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> -<LI>mods for building the software on a Mac using the - MetroWerks CodeWarrior compilers -<LI>a bug in the CCITT T.4/T.6 decoder was fixed where the last codeword in - a strip/tile might not be decoded; this was seen only when decoding - multi-strip images -<LI>a bug in the CCITT RLE codecs was fixed whereby the pseudo tags were not - being properly registered -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="contrib"><B><FONT SIZE=+3>C</FONT>HANGES IN THE CONTRIBUTED SOFTWARE:</B></A> - -<UL> -<LI><B>contrib/mac-cw</B> contains information and code from Niles Ritter - <A HREF=mailto:ndr@tazboy.jpl.nasa.gov><ndr@tazboy.jpl.nasa.gov></A> - about building the software with the MetroWerks CodeWarrior compilers - on Macintosh systems -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -<ADDRESS> -<A HREF="sam.html">Sam Leffler</A> / <A HREF="mailto:sam@engr.sgi.com">sam@engr.sgi.com</A> -Last updated $Date: 1999/08/09 20:21:21 $. -</ADDRESS> - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.4beta031.html b/src/3rdparty/libtiff/html/v3.4beta031.html deleted file mode 100644 index d5b7eac..0000000 --- a/src/3rdparty/libtiff/html/v3.4beta031.html +++ /dev/null @@ -1,94 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Changes in TIFF v3.4beta031 -</TITLE> -</HEAD> - -<BODY> -<FONT FACE="Arial, Helvetica, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.4beta031<BR> -<B>Previous Version</B>: <A HREF=v3.4beta029.html>v3.4beta029</A><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.sgi.com/graphics/tiff">ftp.sgi.com (192.48.153.1), directory graphics/tiff</A><BR> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#man">Changes in the manual pages</A> -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> -<LI><B>configure</B> now captures significantly more information - in the <B>config.log</B> file and provides more information when - it is unable to setup a configuration -<LI>support was added for building shared libraries on more systems: - AIX, HPUX, Solaris, and Linux. -<LI>a new configuration parameter <TT>LIBCOPTS</TT> was added for - passing arguments to the C compiler to use when building only - the library; this is part of the enhanced support for building - shared libraries -<LI>include files for optional packages that reside in <B>/usr/include</B> - are now handled correctly -<LI>build trees may now be configured using either relative or absolute - pathnames to the source distribution -<LI>several new configuration parameters were added, mainly for building - shared libraries: <TT>DIST_MAJOR</TT>, <TT>DIST_MINOR</TT>, - <TT>DIST_ALPHA</TT>, and <TT>DSOSUF_VERSION</TT> -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> -<LI>the Deflate support has been revised: it requires version 0.99 of - the zlib software distribution, <B>the output format has changed and - is incompatible with previous versions of this library</B> (each - strip now includes a header read and written by the zlib library) -<LI>the codec name printed by the TIFFPrintDirectory routine is now - taken from the codec table instead of from a builtin table; this means - that application-defined codecs are handled correctly -<LI>a new symbol was added that contains the library version number; - this can be used to do a compile-time compatibility check of the - library version -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="man"><B><FONT SIZE=+3>C</FONT>HANGES IN THE MANUAL PAGES:</B></A> - -<UL> -<LI>the creation and installation of manual pages was redone; it now - implements the documented ``configuration scheme'' -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -<ADDRESS> -<A HREF="sam.html">Sam Leffler</A> / <A HREF="mailto:sam@engr.sgi.com">sam@engr.sgi.com</A> -Last updated $Date: 1999/08/09 20:21:21 $. -</ADDRESS> - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.4beta032.html b/src/3rdparty/libtiff/html/v3.4beta032.html deleted file mode 100644 index bc14ef3..0000000 --- a/src/3rdparty/libtiff/html/v3.4beta032.html +++ /dev/null @@ -1,90 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Changes in TIFF v3.4beta032 -</TITLE> -</HEAD> - -<BODY> -<FONT FACE="Arial, Helvetica, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.4beta032<BR> -<B>Previous Version</B>: <A HREF=v3.4beta031.html>v3.4beta031</A><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.sgi.com/graphics/tiff">ftp.sgi.com (192.48.153.1), directory graphics/tiff</A><BR> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -<LI><A HREF="#contrib">Changes in the contributed software</A> -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> -<LI>various fixups and subtle improvements to <B>configure</B> - from Richard Mlynarik -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> -<LI>a new codec from Pixar designed for high-resolution color images; - note that this codec is not configured by default -<LI>a bug fix for reading tags with a single <TT>FLOAT</TT> value -<LI>change to the <TT>TIFFGetField</TT> calling convention: - a tag that has a single value of - type <TT>DOUBLE</TT> is now retrieved by passing a - ``<TT>double*</TT>'' instead of a - ``<TT>double**</TT>'' (this change makes the handling of tags with - <TT>DOUBLE</TT> values identical to the handling of tags with - <TT>FLOAT</TT> values) -<LI>fix to VMS support for the handling of floating point values -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> -<LI><B>tiffdump</B> now handles tags with <TT>FLOAT</TT> and <TT>DOUBLE</TT> - values -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="contrib"><B><FONT SIZE=+3>C</FONT>HANGES IN THE CONTRIBUTED SOFTWARE:</B></A> - -<UL> -<LI>updates to the Acorn OS support from Peter Greenham -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -<ADDRESS> -<A HREF="sam.html">Sam Leffler</A> / <A HREF="mailto:sam@engr.sgi.com">sam@engr.sgi.com</A> -Last updated $Date: 1999/08/09 20:21:21 $. -</ADDRESS> - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.4beta033.html b/src/3rdparty/libtiff/html/v3.4beta033.html deleted file mode 100644 index 8d8345a..0000000 --- a/src/3rdparty/libtiff/html/v3.4beta033.html +++ /dev/null @@ -1,82 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Changes in TIFF v3.4beta033 -</TITLE> -</HEAD> - -<BODY> -<FONT FACE="Arial, Helvetica, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.4beta033 (aka the v3.4 release)<BR> -<B>Previous Version</B>: <A HREF=v3.4beta032.html>v3.4beta032</A><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.sgi.com/graphics/tiff">ftp.sgi.com (192.48.153.1), directory graphics/tiff</A><BR> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -<LI><A HREF="#contrib">Changes in the contributed software</A> -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> -<LI>support was added for building the library as a DSO under OSF/1 -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> -<LI>fixes to the Pixar codec -<LI>portability mods for VMS -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> -<LI>fixes to <B>gif2tiff</B> and <B>ppm2tiff</B> for building under MS/DOS -<LI>portability mods to <B>fax2ps</B> and <B>ycbcr</B> for VMS -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="contrib"><B><FONT SIZE=+3>C</FONT>HANGES IN THE CONTRIBUTED SOFTWARE:</B></A> - -<UL> -<LI>a new package from Alexander Lehmann - for building the library and tools under MS/DOS with DJGPP v2 -<LI>updated VMS support from Karsten Spang -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -<ADDRESS> -<A HREF="sam.html">Sam Leffler</A> / <A HREF="mailto:sam@engr.sgi.com">sam@engr.sgi.com</A> -Last updated $Date: 1999/08/09 20:21:21 $. -</ADDRESS> - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.4beta034.html b/src/3rdparty/libtiff/html/v3.4beta034.html deleted file mode 100644 index 77d9863..0000000 --- a/src/3rdparty/libtiff/html/v3.4beta034.html +++ /dev/null @@ -1,68 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Changes in TIFF v3.4beta034 -</TITLE> -</HEAD> - -<BODY> -<FONT FACE="Arial, Helvetica, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.4beta034<BR> -<B>Previous Version</B>: <A HREF=v3.4beta033.html>v3.4beta033</A><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.sgi.com/graphics/tiff">ftp.sgi.com (192.48.153.1), directory graphics/tiff</A><BR> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> -<LI>support was added for building the library as a DSO under NetBSD -<LI>a bug was fixed in the DSO support for Linux -<LI>the handling of version strings has changed slightly to simplify parsing -<LI>a new parameter, <TT>TIFFLIBREF</TT>, was added to control how the - library is referenced when linking programs in the <B>tools</B> directory -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> -<LI>DSO creation under Solaris now forces the DSO name with a <TT>-h</TT> option -<LI>the interface to the <B>mkversion</B> program was changed - to eliminate the need to parse files -<LI>a bug was fixed in the EOL-detection logic of the T.4/T.6 decoder -<LI>ANSI IT8 TIFF/IT tag definitions were added to <B>tiff.h</B> -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -<ADDRESS> -<A HREF="sam.html">Sam Leffler</A> / <A HREF="mailto:sam@engr.sgi.com">sam@engr.sgi.com</A> -Last updated $Date: 1999/08/09 20:21:21 $. -</ADDRESS> - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.4beta035.html b/src/3rdparty/libtiff/html/v3.4beta035.html deleted file mode 100644 index 22fb2b8..0000000 --- a/src/3rdparty/libtiff/html/v3.4beta035.html +++ /dev/null @@ -1,63 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Changes in TIFF v3.4beta035 -</TITLE> -</HEAD> - -<BODY> -<FONT FACE="Arial, Helvetica, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.4beta035<BR> -<B>Previous Version</B>: <A HREF=v3.4beta034.html>v3.4beta034</A><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.sgi.com/graphics/tiff">ftp.sgi.com (192.48.153.1), directory graphics/tiff</A><BR> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> -<LI>support was added installing the HTML documentation -<LI>support was added for building the library as a DSO under FreeBSD -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> -<LI>the interface to the <B>mkversion</B> program was restored to - the form used prior to v3.4beta034 -<LI>several portability problems for 16-bit systems were fixed -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -<ADDRESS> -<A HREF="sam.html">Sam Leffler</A> / <A HREF="mailto:sam@engr.sgi.com">sam@engr.sgi.com</A> -Last updated $Date: 1999/08/09 20:21:21 $. -</ADDRESS> - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.4beta036.html b/src/3rdparty/libtiff/html/v3.4beta036.html deleted file mode 100644 index e36754d..0000000 --- a/src/3rdparty/libtiff/html/v3.4beta036.html +++ /dev/null @@ -1,117 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Changes in TIFF v3.4beta036 -</TITLE> -</HEAD> - -<BODY> -<FONT FACE="Arial, Helvetica, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.4beta036<BR> -<B>Previous Version</B>: <A HREF=v3.4beta035.html>v3.4beta035</A><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.sgi.com/graphics/tiff">ftp.sgi.com (192.48.153.1), directory graphics/tiff</A><BR> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> -<LI>support was added for building the library as a DSO under HP-UX with - the native C compiler -<LI>tools are now built with explicit pathnames for the DSO under IRIX, - Solaris, and Linux -<LI>DSO configuration support for Linux was changed to require that - <B>libc.so</B> only be readable (not executable) -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> -<LI>support was add for ICC: <TT>NumberOfInks</TT>, and <TT>ICCProfile</TT> -<LI>a memory leak caused by doing <TT>TIFFSetDirectory(0)</TT> was fixed -<LI>a bug was fixed whereby certain multi-directory files were not - properly handled when accessed by mapping the data into memory -<LI>the strip chopping support is now always compiled - into the library with the default usage controlled by a - <TT>STRIPCHOP_DEFAULT</TT> configuration parameter -<LI>the strip chopping support no longer chops tiled images -<LI>all static strings are now const--for shared libraries -<LI>the logic for estimating the strip size of images without - a <TT>StripByteCounts</TT> tag was improved by handling - <TT>PlanarContig</TT> images differently from <TT>PlanarSeparate</TT> -<LI>a bug was fixed in the G3 codec when converting the Y resolution - of data specified in metric units -<LI>a bug was fixed in the G3/G4 decoder for data where lines terminate - with a v0 code -<LI>the <TT>TIFFRGBAImage</TT> support was changed to scale 16-bit colormap - entries more conservatively to avoid problems with applications - that do not generate fully saturated pixel values -<LI>the LZW decoder was changed to use a more conservative scheme when - bounds checking the hash table array; this avoids pitfalls with - systems that load objects into memory in unusual locations -<LI>a bug was fixed in <TT>TIFFPrintDirectory</TT>'s handling of the - <TT>InkNames</TT> tag -<LI><TT>TIFFPrintDirectory</TT> now understands <TT>NumberOfInks</TT> - and ICC-related tags -<LI>the routines for reading image data now provide more useful information - when a read error is encountered -<LI>support was added for compiling with Microsoft Visual C++ 4.0 -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> -<LI>a bug was fixed in <B>pal2rgb</B>'s colormap handling -<LI><B>tiff2ps</B> now includes John Wehle's changes for maintaining - the aspect ratio - of images when scaling and for honoring the deadzone on a page when - generating PostScript Level II -<LI><B>tiff2ps</B> does a better job guarding against the mishandling - of greyscale images -<LI><B>tiff2ps</B> now correctly converts X- and Y-resolution values - specified in metric units -<LI><B>tiffdump</B> has a new <TT>-m</TT> option to control the maximum - number of indirect - data values printed for a tag (by default 24) -<LI><B>tiffdump</B> understands several new tags -<LI><B>tiffdump</B> now shows any terminating null in ASCII strings -<LI><B>tiffinfo</B> now suppresses strip chopping when interpreting an image; - a new <TT>-z</TT> option has been added to enable strip chopping -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -<ADDRESS> -<A HREF="sam.html">Sam Leffler</A> / <A HREF="mailto:sam@engr.sgi.com">sam@engr.sgi.com</A> -Last updated $Date: 1999/08/09 20:21:21 $. -</ADDRESS> - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.5.1.html b/src/3rdparty/libtiff/html/v3.5.1.html deleted file mode 100644 index 0c88de9..0000000 --- a/src/3rdparty/libtiff/html/v3.5.1.html +++ /dev/null @@ -1,75 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Changes in TIFF v3.5.1 -</TITLE> -</HEAD> - -<BODY BGCOLOR=white> -<FONT FACE="Arial, Helvetica, Sans"> -<FONT FACE="Arial, Helvetica, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.5.1<BR> -<B>Previous Version</B>: v3.4beta037<BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.onshore.com/pub/libtiff">ftp.onshore.com, directory graphics/tiff</A><BR> -<B>Master HTTP Site</B>: <A HREF="http://www.remotesensing.org/libtiff/>http://www.remotesensing.org/libtiff</a> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> - <LI> <em> None of consequence </em> -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - - -<UL> -<LI> Support was added for IPTC Newsphoto metadata (TIFFTAGE_IPTCNEWSPHOTO) -<LI> Support was added for photoshop caption handling (TIFFTAG_PHOTOSHOP) -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> -<LI> <A HREF=mailto:billr@corbis.com>Bill Radcliffe's</a> iptcutil was -added to the "contrib" subdirectory . It can convert an IPTC binary -blob to ASCII text and vice-versa. The blob itself can be extracted -from or added to an image with the <A -href=http://www.ImageMagick.org/>ImageMagick</a> convert(1) -utility. -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -Last updated $Date: 2006/01/03 01:42:30 $. - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.5.2.html b/src/3rdparty/libtiff/html/v3.5.2.html deleted file mode 100644 index 71b486a..0000000 --- a/src/3rdparty/libtiff/html/v3.5.2.html +++ /dev/null @@ -1,108 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Changes in TIFF v3.5.2 -</TITLE> -</HEAD> - -<BODY BGCOLOR=white> -<FONT FACE="Arial, Helvetica, Sans"> -<FONT FACE="Arial, Helvetica, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.5.2<BR> -<B>Previous Version</B>: <A HREF=v3.5.1.html>v3.5.1</a><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.onshore.com/pub/libtiff">ftp.onshore.com, directory graphics/tiff</A><BR> -<B>Master HTTP Site</B>: <A HREF="http://www.remotesensing.org/libtiff/">http://www.remotesensing.org/libtiff</a> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> - <LI> Corrected alpha versioning. - - <LI> Removed distinction between alpha and release targets in Makefile.in. - - <LI> Added release.stamp target, which tags cvs tree, and updates - "RELEASE-DATE" - - <LI> Added releasediff target, which diffs tree with source as of - date in "RELEASE-DATE" - - <LI>Ticked up version to 3.5.2 (alpha 01 -- but I think we'll moving - away from alpha/non-alpha distinctions). - -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - - -<UL> - <LI> Added IRIX/gcc, and OSF/1 4.x support on behalf of - Albert Chin-A-Young <china@thewrittenword.com> - - <LI> Added TIFFReassignTagToIgnore() API on behalf of - Bruce Cameron <cameron@petris.com>. Man page still pending. - - <LI> pre-remove so link before softlink in LINUXdso action in - libtiff/Makefile.in to avoid failure on LINUXdso builds other than - the first. - - <LI> Fixed problem with cvtcmap() in tif_getimage.c modifying the - colormaps owned by the TIFF handle itself when trying to fixup wrong - (eight bit) colormaps. Corrected by maintaining a private copy of - the colormap. - - <LI> Added TIFFReadRGBATile()/TIFFReadRGBAStrip() support in - tif_getimage.c. - - <LI> Applied "a" mode fix to tif_win32.c/TIFFOpen() as suggested - by Christopher Lawton <clawton@mathworks.com> - - <LI> Set O_BINARY for tif_unix.c open() ... used on cygwin for instance. - - <LI> Added CYGWIN case in configure. - - <LI> Applied Francois Dagand's patch to handle fax decompression bug. - (sizes >= 65536 were failing) -</UL> - -<P><HR WIDTH=65% ALIGN=right> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> - <LI> Added addtiffo (add overviews to a TIFF file) in contrib. Didn't - put it in tools since part of it is in C++. -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -Last updated $Date: 2004/11/26 14:37:20 $. - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.5.3.html b/src/3rdparty/libtiff/html/v3.5.3.html deleted file mode 100644 index e7910d9..0000000 --- a/src/3rdparty/libtiff/html/v3.5.3.html +++ /dev/null @@ -1,132 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Changes in TIFF v3.5.3 -</TITLE> -</HEAD> - -<BODY BGCOLOR=white> -<FONT FACE="Arial, Helvetica, Sans"> -<FONT FACE="Arial, Helvetica, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.5.3<BR> -<B>Previous Version</B>: <A HREF=v3.5.2.html>v3.5.2</a><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.onshore.com/pub/libtiff">ftp.onshore.com</a>, directory pub/libtiff</A><BR> -<B>Master HTTP Site</B>: <A HREF="http://www.remotesensing.org/libtiff/">http://www.remotesensing.org/libtiff</a> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -</UL> -<p> -The ChangeLog will follow, but please note the most important change: -LZW compression has been removed. -<p> -Unisys has the patent on LZW compression and have been very active in -their enforcement of late, demanding payments of $5000 or more from -websites using unlicensed software to create GIF's. They could well -do the same do persons using libtiff to create LZW compressed TIFF -images. -<p> -From <A HREF=http://burnallgifs.org>Burn All GIF's Day</a>: -<br> -<em>The catch is that it appears to be difficult or impossible to get a -Unisys license to use LZW in free software that complies with the Open -Source Definition</em> -<P> -Unfortunatly, the removal of LZW compression means that saved image size has -grown dramatically. Without a change in the TIFF spec to support -another lossless compression format, this is unavoidable. -<P> -The library can use zip for lossless compression, but as this is not -part of the spec, TIFFs using zip compression may not work with other -software -<P> -We will be making a patch available that will contain the LZW -compression code for users who have either obtained a license from -Unisys or are willing to risk it. -<p> -LZW decompression is unchanged. -<p> -<P><HR WIDTH=65% ALIGN=left> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> - <LI> Added zip creation to release makefile target - - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - - -<UL> - - <LI> Added html for TIFFWriteTile.3t man page. - - <LI> Added some changes to tif_write.c to support rewriting existing - fixed sized tiles and strips. Code mods disabled by default, only - enabled if REWRITE_HACK is defined for now. - - <LI> Added TIFFWriteTile.3t man page. - - <LI> Added notes on use of makefile.vc in build.html, and fixed - email subscription address. - - <LI> Fixed apocalypse-inducing y2k bug in contrib/ras/ras2tiff.c - - <LI> Did some casts cleaning up to reduce compiler warnings in tif_fax3.c, - from Bruce Carmeron <cameron@petris.com> -- modifications of - changes made by Frank (sun cc still complained on cast). - - <LI> fixed various VC++ warnings as suggested by Gilles Vollant - <info@winimage.com>. - - <LI> Modified TIFFquery.3t man pages info on TIFFIsByteSwapped() to - not imply applications are responsible for image data swapping. - - <LI> HTML-ized the man pages, added to html/man - - <LI> Removed LZW Compression to comply with Unisys patent extortion. - - <LI> Corrected one remaining 16 -> 32 bit value in tif_fax3.c, - From Ivo Penzar <ivo.penzar@infolink-software.com. - - <LI> Added patch from Ivo Penzar to have TiffAdvanceDirectory handle - memory mapped files. <ivo.penzar@infolink-software.com> -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> - <LI> Fixed apocalypse-inducing y2k bug in contrib/ras/ras2tiff.c -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -Last updated $Date: 2004/11/26 14:37:20 $. - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.5.4.html b/src/3rdparty/libtiff/html/v3.5.4.html deleted file mode 100644 index 714621e..0000000 --- a/src/3rdparty/libtiff/html/v3.5.4.html +++ /dev/null @@ -1,88 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Changes in TIFF v3.5.4 -</TITLE> -</HEAD> - -<BODY BGCOLOR=white> -<FONT FACE="Helvetica, Arial, Sans"> -<FONT FACE="Helvetica, Arial, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.5.4<BR> -<B>Previous Version</B>: <A HREF=v3.5.3.html>v3.5.3</a><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.onshore.com/pub/libtiff">ftp.onshore.com</a>, directory pub/libtiff</A><BR> -<B>Master HTTP Site</B>: <A HREF="http://www.remotesensing.org/libtiff/">http://www.remotesensing.org/libtiff</a> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -</UL> -<p> -<P><HR WIDTH=65% ALIGN=left> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> - <LI> None - - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - - -<UL> - - <li> Added Pixar tag support. Contributed by Phil Beffery <phil@pixar.com> - - <li> Made one more change to tif_dir.c for removal of LZW compression. Also added notice - when LZW compression invoked. - - <li> Fixed bug that caused LZW (non) compression to segfault. Added - warning about LZW compression removed being removed, and why. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> - <li> Changed default compression in tools to TIFF_PACKBITS, and changed usage descriptions - in tools to reflect removal of LZW compression - - <li> Added nostrip to install in tools/Makefile.in so that debugging - symbols are kept. - - <li> Made Packbits the default compression in tools/tiff2rgba.c instead - of LZW. - - -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -Last updated $Date: 2006/01/03 01:45:41 $. - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.5.5.html b/src/3rdparty/libtiff/html/v3.5.5.html deleted file mode 100644 index 20be92f..0000000 --- a/src/3rdparty/libtiff/html/v3.5.5.html +++ /dev/null @@ -1,155 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Changes in TIFF v3.5.5 -</TITLE> -</HEAD> - -<BODY BGCOLOR=white> -<FONT FACE="Helvetica, Arial, Sans"> -<FONT FACE="Helvetica, Arial, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.5.5<BR> -<B>Previous Version</B>: <A HREF=v3.5.4.html>v3.5.4</a><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.onshore.com/pub/libtiff">ftp.onshore.com</a>, directory pub/libtiff</A><BR> -<B>Master HTTP Site</B>: <A HREF="http://www.remotesensing.org/libtiff/">http://www.remotesensing.org/libtiff</a> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -<LI><A HREF="#lzwkit">Changes in the LZW compression kit</A> -</UL> -<p> -<P><HR WIDTH=65% ALIGN=left> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> - - <LI> configure: added test for libc6 for linux targets. Bug reported by - Stanislav Brabec <utx@k332.feld.cvut.cz> - - <LI> configure: fixed bugs in sed scripts - (applied sed script s:/@:s;@:;s:/s;;:;: to configure). - fix submitted by Stanislav Brabec <utx@k332.feld.cvut.cz> - - <LI> tools/iptcutil was not in files list, and wasn't being - added to tar archive. Updated Makefile.in. - - <LI> Added 3.5 docs to html/Makefile.in. - Thanks to Stanislav Brabec <utx@k332.feld.cvut.cz> - - <LI> Fixed tools/tiffcmp so that stopondiff testing works. - Patch care of Joseph Orost <joe@sanskrit.lz.att.com>. - - <LI> Added fax3sm_winnt.c to distribution list in Makefile.in. - - <LI> Added libtiff/libtiff.def to TIFFILES distribution list. -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - - -<UL> - <LI>tif_fax3.c: Fixed serious bug introduced during the uint16->uint32 - conversion for the run arrays. - - <LI> Set td_sampleformat default to SAMPLEFORMAT_UINT instead of - SAMPLEFORMAT_VOID in TIFFDefaultDirectory() in tif_dir.c. - - <LI> Added "GetDefaulted" support for TIFFTAG_SAMPLEFORMAT in tif_aux.c. - - <LI> Patched tif_fax3.c so that dsp->runs is allocated a bit bigger - to avoid overruns encountered with frle_bug.tif. - - - <LI> Modified tif_unix.c to support 2-4GB seeks if USE_64BIT_API is - set to 1, and added default (off) setting in tiffconf.h. This - should eventually be set by the configure script somehow. - - The original work on all these 2-4GB changes was done by - Peter Smith (psmith@creo.com). - - <LI> Modified tif_win32.c to support 2-4GB seeks. - - <LI> tentatively changed toff_t to be unsigned instead of signed to - facilitate support for 2-4GB files. - - <LI> Updated a variety of files to use toff_t. Fixed some mixups - between toff_t and tsize_t. - - <LI> Set tif_rawdatasize to zero when freeing raw data buffer in - TIFFWriteDirectory(). - - <LI> Enabled "REWRITE_HACK" in tif_write.c by default. - - <LI> Fix bug in tif_write.c when switching between reading one directory - and writing to another. - - <LI> Made TIFFWriteCheck() public, and added TIFFCreateDirectory() - - <LI> Added TIFFmemory(3t) functions to libtiff.def. - - <LI> Added libtiff/libtiff.def to TIFFILES distribution list. -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> - <LI> fax2ps: Fixed mixup of width and height in bounding box statement - as per submission by Nalin Dahyabhai <nalin@redhat.com>. - - <LI> fax2ps: Modified printruns to take uint32 instead of uint16. - Patch courtesy of Bernt Herd <herd@herdsoft.com> - - - <LI> Largely reimplemented contrib/addtiffo to avoid temp files, - updating the TIFF file in place. Fixed a few other bugs to. - - <LI> Altered descriptions in tools to reflect "by default" lzw not supported -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<A NAME="lzwkit"><B><FONT SIZE=+3>C</FONT>HANGES IN THE LZW COMPRESSION KIT</B></A> -<UL> - <LI>created mangle-src.sh -- sed scripts to munge src into LZW enabled format. Thanks to Stanislav Brabec <utx@k332.feld.cvut.cz> - - <LI>created Makefile - - <LI>merged tif_dir.c with current source. - - - <LI> Created lzw compression kit, as a new CVS module (libtiff-lzw-compression-kit). - - <LI> Updated index.html to note lzw compression kit. - -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -Last updated $Date: 2004/11/26 14:37:20 $. - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.5.6-beta.html b/src/3rdparty/libtiff/html/v3.5.6-beta.html deleted file mode 100644 index 682f845..0000000 --- a/src/3rdparty/libtiff/html/v3.5.6-beta.html +++ /dev/null @@ -1,185 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Changes in TIFF v3.5.6 -</TITLE> -</HEAD> - -<BODY BGCOLOR=white> -<FONT FACE="Helvetica, Arial, Sans"> -<FONT FACE="Helvetica, Arial, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.5.6beta<BR> -<B>Previous Version</B>: <A HREF=v3.5.5.html>v3.5.5</a><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.onshore.com/pub/libtiff">ftp.onshore.com</a>, directory pub/libtiff</A><BR> -<B>Master HTTP Site</B>: <A HREF="http://www.remotesensing.org/libtiff/">http://www.remotesensing.org/libtiff</a> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -<LI><A HREF="#contrib">Changes in contrib</A> -<LI><A HREF="#lzwkit">Changes in the LZW compression kit</A> -</UL> -<p> -<P><HR WIDTH=65% ALIGN=left> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> - - <LI> Added GNULDdso target and switched linux and freebsd to use it. - <LI> tools/Makefile.in: Modified to install properly on SGI. - <LI> configure: Fixed DSO test for Linux as per patch from - Jan Van Buggenhout <chipzz@Ace.ULYSSIS.Student.KULeuven.Ac.Be>. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - - -<UL> - - <LI> tif_dir.c: Clear TIFF_ISTILED flag in TIFFDefaultDirectory - as per http://bugzilla.remotesensing.org/show_bug.cgi?id=18 - from vandrove@vc.cvut.cz. - - <LI> Modified tif_packbits.c decoding to avoid overrunning the - output buffer, and to issue a warning if data needs to be - discarded. See http://bugzilla.remotesensing.org/show_bug.cgi?id=18 - - <LI> Modified TIFFClientOpen() to emit an error on an attempt to - open a comperessed file for update (O_RDWR/r+) access. This is - because the compressor/decompressor code gets very confused when - the mode is O_RDWR, assuming this means writing only. See - bug http://bugzilla.remotesensing.org/show_bug.cgi?id=13 - - <LI> Applied patch for 0x0000 sequences in tif_fax3.h's definition - of EXPAND1D() as per bug 11 (from Roman). - - <LI> Fixed tiffcomp.h to avoid win32 stuff if unix #defined, to improve - cygwin compatibility. - - <LI> Applied patch from Roman Shpount to tif_fax3.c. This seems to - be a proper fix to the buffer sizing problem. See - http://bugzilla.remotesensing.org/show_bug.cgi?id=11 - - <LI> Fixed tif_getimage.c to fix overrun bug with YCbCr images without - downsampling. http://bugzilla.remotesensing.org/show_bug.cgi?id=10 - Thanks to Nick Lamb <njl98r@ecs.soton.ac.uk> for reporting the - bug and proving the patch. - - <LI> Fixed tif_jpeg.c so avoid destroying the decompressor before - we are done access data thanks to bug report from: - Michael Eckstein <eckstein@gepro.cz>. - - <LI> tif_open.c: Don't set MMAP for O_RDWR files. - - <LI> tif_open.c: Set STRIPCHOP_DEFAULT for O_RDWR as well as O_RDONLY - so that files opened for update can be strip chopped too. - - <LI> tif_read.c: fixed up bug with files missing rowsperstrip and - the strips per separation fix done a few weeks ago. - - <LI> Tentatively added support for SAMPLEFORMAT_COMPLEXIEEEFP, and - SAMPLEFORMAT_COMPLEXINT. - - <LI> index.html, bugs.html: added bugzilla info. - - <LI> tif_read.c: fix subtle bug with determining the number of - rows for strips that are the last strip in a separation but - not the last strip of all in TIFFReadEncodedStrip(). - - <LI> Applied 16/32 bit fix to tif_fax3.c. Fix supplied by - Peter Skarpetis <peters@serendipity-software.com.au> - - <LI> Modified tiffio.h logic with regard to including windows.h. It - won't include it when building with __CYGWIN__. - - <LI> README: update to mention www.libtiff.org, don't list Sam's old - email address. - - <LI> libtiff/tif_dirread.c: Don't use estimate strip byte count for - one tile/strip images with an offset, and byte count of zero. These - could be "unpopulated" images. - - <LI> tif_win32.c: Applied patch to fix overreads and ovverwrites - caught by BoundsChecker. From Arvan Pritchard - <arvan.pritchard@infomatix.co.uk> (untested). - - <LI> tif_getimage.c: Applied patch to silence VC6 warnings. From - Arvan Pritchard <arvan.pritchard@informatix.co.uk> - - <LI> tif_lzw.c: Applied patch to silence VC6 warnings. From - Arvan Pritchard <arvan.pritchard@informatix.co.uk> - - <LI> libtiff/tif_apple.c: Applied "Carbon" support patches supplied by - Leonard Rosenthol <leonardr@lazerware.com>. May interfere - with correct building on older systems. If so, please let me know. - - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> - - <LI> tools/rgb2ycbcr.c: fixed output strip size to account for vertical - roundup if rows_per_strip not a multiple of vertical sample size. - - <LI> tools/tiffsplit.c: Copy TIFFTAG_SAMPLEFORMAT. - - <LI> Modified tiff2bw to ensure portions add to 100%, and that - white is properly recovered. See bug - http://bugzilla.remotesensing.org/show_bug.cgi?id=15 Patch - c/o Stanislav Brabec <utx@penguin.cz> - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<A NAME="contrib"><B><FONT SIZE=+3>C</FONT>HANGES IN CONTRIB:</B></A> - -<UL> - - <LI> contrib/addtiffo: Added "averaging" resampling option. - - <LI> Added contrib/stream (stream io) code submitted by Avi Bleiweiss. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<A NAME="lzwkit"><B><FONT SIZE=+3>C</FONT>HANGES IN THE LZW COMPRESSION KIT</B></A> -<UL> - - <LI> updated tif_dir.c to reflect changes to no-lzw tif_dir.c - -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -Last updated $Date: 2006/03/18 17:12:47 $. - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.5.7.html b/src/3rdparty/libtiff/html/v3.5.7.html deleted file mode 100644 index 528df74..0000000 --- a/src/3rdparty/libtiff/html/v3.5.7.html +++ /dev/null @@ -1,259 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Changes in TIFF v3.5.7 -</TITLE> -</HEAD> - -<BODY BGCOLOR=white> -<FONT FACE="Helvetica, Arial, Sans"> -<FONT FACE="Helvetica, Arial, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.5.7<BR> -<B>Previous Version</B>: <A HREF=v3.5.6-beta.html>v3.5.6 Beta</a><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.remotesensing.org/pub/libtiff">ftp.remotesensing.org</a>, directory pub/libtiff</A><BR> -<B>Master HTTP Site</B>: <A HREF="http://www.remotesensing.org/libtiff/">http://www.remotesensing.org/libtiff</a> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -<LI><A HREF="#lzwkit">Changes in the LZW compression kit</A> -</UL> -<p> -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> -<li> libtiff/libtiff.def: Brent Roman submitted new version adding -serveral missing entry points. Also add a few other entry points -later. - -<li> configure, Makefile.in, etc: added support for OPTIMIZER being - set from config.site. -<li> config.guess: updated wholesale to an FSF version apparently - from 1998 (as opposed to 1994). This is mainly inspired by - providing for MacOS X support. - -<li> configure/config.site: modified to check if -lm is needed for - MACHDEPLIBS if not supplied by config.site. Needed for Darwin. -<li> libtiff/tiff.h: Applied hac to try and resolve the problem - with the inttypes.h include file on AIX. (Bug 39) - -<li> configure, *Makefile.in: Various changes to improve configuration - for HP/UX specifically, and also in general. (Bug 40) They include: -<ul> - <li> Try to handle /usr/bin/sh instead of /bin/sh where necessary. - <li> Upgrade to HP/UX 10.x+ compiler, linker and dso options. - <li> Fixed mmap() test to avoid MMAP_FIXED ... it isn't available on HP - <li> Use -${MAKEFLAGS} in sub makes from makefiles. - <li> Fixed SCRIPT_SH/SHELL handling. -</ul> -<li> configure: Changes for DSO generation on AIX provided by - John Marquart <jomarqua@indiana.edu>. - -<li> configure, libtiff/Makefile.in: Modified to build DSOs properly - on Darwin thanks to Robert Krajewski (rpk@alum.mit.edu) and - Keisuke Fujii (fujiik@jlcuxf.kek.jp). - -<li> configure, libtiff/Makefile.in: applied OpenBSD patches as per bug 61. - -<li> Makefile.in: added DESTDIR support as per bug 60. - -<li> libtiff/tif_jpeg.c: Define HAVE_BOOLEAN on windows if RPCNDR.H - has been included. -<li> man/Makefile.in: add TIFFClientOpen link as per debian submitted - bug 66. -<li> libtiff/Makefile.in: Fixed @DSOSUB_VERSION to be @DSOSUF_VERSION@ - in two places. -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - - -<UL> -<li> tif_fax3.c: keep rw_mode flag internal to fax3 state to remember - whether we are encoding or decoding. This is to ensure graceful - recovery if TIFFClientOpen() discovers an attempt to open a compressed - file for "r+" access, and subsequently close it, as it resets the - tif_mode flag to O_RDONLY in this case to avoid writes, confusing the - compressor's concept of whether it is in encode or decode mode. -<li> tif_luv.c/tiff.h/tiffio.h: - New version of TIFF LogLuv (SGILOG) modules contributed by Greg Ward - (greg@shutterfly.com). He writes: - -<ol> - <li> I improved the gamut-mapping function in tif_luv.c for imaginary - colors, because some images were being super-saturated on the input - side and this resulted in some strange color shifts in the output. - - <li> I added a psuedotag in tiff.h to control random dithering during - LogLuv encoding. This is turned off by default for 32-bit LogLuv and - on for 24-bit LogLuv output. Dithering improves the average color - accuracy over the image. - - <li> I added a #define for LOG_LUV_PUBLIC, which is enabled by default in - tiffio.h, to expose internal routines for converting between LogLuv and - XYZ coordinates. This is helpful for writing more efficient, - specialized conversion routines, especially for reading LogLuv files. -</ol> - -<li> libtiff/tif_dirinfo.c: don't declare tiffFieldInfo static on VMS. - -<li> Added TIFFTAG_COPYRIGHT support. -<li> tif_getimage.c: Added support for 16bit minisblack/miniswhite - images in RGBA interface. -<li> libtiff/tif_dirinfo.c: removed duplicate TIFFTAG_PHOTOSHOP as per - bug 44. -<li> libtiff/tif_dirwrite.c: Added support for TIFF_VARIABLE2 in the - case of writing TIFF_BYTE/TIFF_SBYTE fields as per bug 43. - -<li> libtiff/tif_dirinfo.c: Modified the TIFF_BYTE definition for - TIFFTAG_PHOTOSHOP to use a writecount of TIFF_VARIABLE2 (-3) to - force use of uint32 counts instead of short counts. - -<li> libtiff/tif_dirinfo.c: moved pixar and copyright flags to - ensure everything is in order. - -<li> Integrated experimental OJPEG support from Scott Marovich of HP. - -<li> libtiff/tif_open.c: Seek back to zero after failed read, - before writing header. - -<li> libtiff/tiff.h, libtiff/tif_fax3.c: added check for __LP64__ - when checking for 64 bit architectures as per bugzilla bug 67. -<li> libtiff/tif_getimage.c: Use memmove() instead of TIFFmemcpy() - in TIFFReadRGBATile() to avoid issues in cases of overlapping - buffers. See Bug 69 in Bugzilla. -<li> libtiff/tif_getimage.c: Don't complain for CMYK (separated) - images with more than four samples per pixel as per bug 73. - -<li> libtiff/tif_getimage.c: relax handling of contig case where -there are extra samples that are supposed to be ignored as per bug 75. This -should now work for 8bit greyscale or palletted images. - -<li> libtiff/tif_packbits.c: fixed memory overrun error as per bug 77. - -<li> libtiff/tif_getimage.c: Fixed problem with reading strips or -tiles that don't start on a tile boundary. Fix contributed by -Josep Vallverdu (from HP), and further described in bug 47. - -<li> libtif/tif_fax3.c: Removed #ifdef PURIFY logic, and modified to - always use the "safe" version, even if there is a very slight - cost in performance as per bug 54. -<li> libtiff/tif_lzw.c: added dummy LZWSetupEncode() to report an - error about LZW not being available. - -<li> libtiff/tif_dir.c: propagate failure to initialize compression - back from TIFFSetField() as an error status, so applications can - detect failure. - -<li> libtiff/tif_lzw.c: Avoid MS VC++ 5.0 optimization bug as per bug 78. - -<li> libtiff/tif_dirwrite.c: added TIFFRewriteDirectory() function. -Updated TIFFWriteDirectory man page to include TIFFRewriteDirectory. - -<li> libtiff/tiff.h: I have created COMPRESSION_CCITT_T4, - COMPRESSION_CCITT_T6, TIFFTAG_T4OPTIONS and TIFFTAG_T6OPTIONS aliases - in keeping with TIFF 6.0 standard in tiff.h as per bug 83. - -<li> Added PHOTOMETRIC_ITULAB as per bug 90. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!--------------------------------------------------------------------------> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> -<li> Brent Roman contributed updated tiffcp utility (and tiffcp.1) - with support for extracting subimages with the ,n syntax, and also - adding the -b bias removal flag. -<li> tiff2ps.c/tiff2ps.1: Substantial changes to tiff2ps by - Bruce A. Mallett, including a faster encoder, fixes for level - 2 PostScript, and support for the imagemask operator. -<li> fax2ps.c: Helge (libtiff at oldach.net) submitted fix -that corrects behaviour for non-Letter paper -sizes. (Bug 35) It fixes two problems: -<br> - Without scaling (-S) the fax is now centered on the page size specified - with -H and/or -W. Before, fax2ps was using an obscure and practially - useless algorithm to allocate the image relative to Letter sized paper - which sometime sled to useless whitespace on the paper, while at the - same time cutting of the faxes printable area at the opposite border. -<br> - - Second, scaling now preserves aspect ratio, which makes unusual faxes - (in particular short ones) print properly. - -<li> thumbnail.c: changed default output compression - to packbits from LZW since LZW isn't generally available. -<li> tiff2rgba.c: added -n flag to avoid emitting alpha component. Also added -a man page for tiff2rgba. - -<li> tiffcmp.c: Fixed multi samples per pixel support for ContigCompare -as per bug 53. -Updated bug section of tiffcmp.1 to note tiled file issues. - -<li> libtiff/tif_getimage.c: Fixed so that failure is properly - reported by gtTileContig, gtStripContig, gtTileSeparate and - gtStripSeparate as per bug 51. - - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="lzwkit"><B><FONT SIZE=+3>C</FONT>HANGES IN THE LZW COMPRESSION KIT:</B></A> -<UL> - <LI> Rewrote lzw patching process so that is required to enable full - LZW support is to drop the tif_lzw.c from the - libtiff-lzw-compression-kit over the one in the libtiff directory. - - <LI> Some changes were made to make recovery from failure to - initialize the LZW compressor more graceful. - - <LI> Note that as distributed libtiff support LZW decompression, but - not LZW compression. -</UL> - -<!---------------------------------------------------------------------------> - -<A NAME="contrib"><B><FONT SIZE=+3>C</FONT>HANGES IN THE CONTRIB AREA:</B></A> -<UL> -<li> Fixed distribution to include contrib/addtiffo/tif_ovrcache.{c,h}. -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -Last updated $Date: 2004/11/26 14:37:20 $. - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.6.0.html b/src/3rdparty/libtiff/html/v3.6.0.html deleted file mode 100644 index 888e547..0000000 --- a/src/3rdparty/libtiff/html/v3.6.0.html +++ /dev/null @@ -1,434 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Changes in TIFF v3.6.0 -</TITLE> -</HEAD> - -<BODY BGCOLOR=white> -<FONT FACE="Helvetica, Arial, Sans"> -<FONT FACE="Helvetica, Arial, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.6.0<BR> -<B>Previous Version</B>: <A HREF=v3.5.7.html>v3.5.7</a><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.remotesensing.org/pub/libtiff"> -ftp.remotesensing.org</a>, directory pub/libtiff</A><BR> -<B>Master HTTP Site</B>: <A HREF="http://www.remotesensing.org/libtiff"> -http://www.remotesensing.org/libtiff</a> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#hightlights">Major Changes</A> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -<LI><A HREF="#contrib">Changes in the contrib area</A> -<LI><A HREF="#lzwkit">Changes in the LZW compression kit</A> -</UL> -<p> -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="highlights"><B><FONT SIZE=+3>M</FONT>AJOR CHANGES:</B></A> - -<ul> - <li> New utility <a href=./man/raw2tiff.1.html>raw2tiff</a> -for converting raw rasters into TIFF files. - <li> Lots of new <a href=./man/tiff2ps.1.html>tiff2ps</a> options. - <li> Lots of new <a href=./man/fax2tiff.1.html>fax2tiff</a> options. - <li> Lots of bug fixes for LZW, JPEG and OJPEG compression. -</ul> - -<h3>Custom Tag Support</h3> - -The approach to extending libtiff with custom tags has changed radically. -Previously, all internally supported TIFF tags had a place in the -private TIFFDirectory structure within libtiff to hold the values (if read), -and a "field number" (ie. FIELD_SUBFILETYPE) used to identify that tag. -However, every time a new tag was added to the core, the size of the -TIFFDirectory structure would changing, breaking any dynamically linked -software that used the private data structures.<p> - -Also, any tag not recognised -by libtiff would not be read and accessable to applications without some -fairly complicated work on the applications part to pre-register the tags -as exemplified by the support for "Geo"TIFF tags by libgeotiff layered on -libtiff. <p> - -Amoung other things this approach required the extension code -to access the private libtiff structures ... which made the higher level -non-libtiff code be locked into a specific version of libtiff at compile time. -This caused no end of bug reports!<p> - -The new approach is for libtiff to read all tags from TIFF files. Those that -aren't recognised as "core tags" (those having an associated FIELD_ value, -and place for storage in the TIFFDirectory structure) are now read into a -dynamic list of extra tags (td_customValues in TIFFDirectory). When a new -tag code is encountered for the first time in a given TIFF file, a new -anonymous tag definition is created for the tag in the tag definition list. -The type, and some other metadata is worked out from the instance encountered. -These fields are known as "custom tags". <p> - -Custom tags can be set and fetched normally using TIFFSetField() and -TIFFGetField(), and appear pretty much like normal tags to application code. -However, they have no impact on internal libtiff processing (such as -compression). Some utilities, such as tiffcp will now copy these custom -tags to the new output files. <p> - -As well as the internal work with custom tags, new C API entry points -were added so that extension libraries, such as libgeotiff, could -define new tags more easily without accessing internal data structures. -Because tag handling of extension tags is done via the "custom fields" -mechanism as well, the definition provided externally mostly serves to provide -a meaningful name for the tag. - -The addition of "custom tags" and the altered approach to extending libtiff -with externally defined tags is the primary reason for the shift to the -3.6.x version number from 3.5.x.<p> - -<P><HR WIDTH=65% ALIGN=left> -<!---------------------------------------------------------------------------> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> -<li> configure, config.site: Fix for large files (>2GiB) support. New -option in the config.site: LARGEFILE="yes". Should be enougth for the large -files I/O. - -<li> configure: Set -DPIXARLOG_SUPPORT option along with -DZIP_SUPPORT. - -<li> html/Makefile.in: Updated to use groffhtml for generating html pages -from man pages. - -<li> configure, libtiff/Makefile.in: Added SCO OpenServer 5.0.6 support -from John H. DuBois III. - -<li> libtiff/{Makefile.vc, libtiff.def}: Missed declarations added. - -<li> libtiff/Makefile.in, tools/Makefile.in: Shared library will not be -stripped when installing, utility binaries will do be stripped. As per bug 93. - -<li> man/Makefile.in: Patch DESTDIR handling as per bug 95. - -<li> configure: OpenBSD changes for Sparc64 and DSO version as per bug 96. - -<li> config.site/configure: added support for OJPEG=yes option to enable -OJPEG support from config.site. - -<li> config.guess, config.sub: Updated from ftp.gnu.org/pub/config. - -<li> configure: Modify CheckForBigEndian so it can work in a cross -compiled situation. - -<li> configure, libtiff/Makefile.in: Changes for building on MacOS 10.1 -as per bug 94. - -<li> html/Makefile.in: added missing images per bug 92. - -<li> port/Makefile.in: fixed clean target per bug 92. -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> - -<li> libtiff/tif_getimage.c: New function <A -HREF="./man/TIFFReadRGBAImage.3t.html">TIFFReadRGBAImageOriented()</A> -implemented to retrieve raster array with user-specified origin position. - -<li> libtiff/tif_fax3.c: Fix wrong line numbering. - -<li> libtiff/tif_dirread.c: Check field counter against number of fields. - -<li> Store a list of opened IFD to prevent directory looping. - -<li> libtiff/tif_jpeg.c: modified segment_height calculation to always -be a full height tile for tiled images. Also changed error to just -be a warning. - -<li> libtiff/tif_lzw.c: fixed so that decoder state isn't allocated till -LZWSetupDecode(). Needed to read LZW files in "r+" mode. - -<li> libtiff/tif_dir.c: fixed up the tif_postdecode settings responsible -for byte swapping complex image data. - -<li> libtiff/tif_open.c: Removed error if opening a compressed file -in update mode bug (198). - -<li> libtiff/tif_write.c: TIFFWriteCheck() now fails if the image is -a pre-existing compressed image. That is, image writing to pre-existing -compressed images is not allowed. - -<li> html/man/*.html: Web pages regenerated from man pages. - -<li> libtiff/tif_jpeg.c: Hack to ensure that "boolean" is defined properly -on Windows so as to avoid the structure size mismatch error from libjpeg -(bug 188). - -<li> libtiff/tiff.h: #ifdef USING_VISUALAGE around previous Visual Age -AIX porting hack as it screwed up gcc. (bug 39) - -<li> libtiff/tiff.h: added COMPRESSION_JP2000 (34712) for LEAD tools -custom compression. - -<li> libtiff/tif_dirread.c: Another fix for the fetching SBYTE arrays -by the TIFFFetchByteArray() function. (bug 52) - -<li> libtiff/tif_dirread.c: Expand v[2] to v[4] in TIFFFetchShortPair() -as per bug 196. - -<li> libtiff/tif_lzw.c: Additional consistency checking added in -LZWDecode() and LZWDecodeCompat() fixing bugs 190 and 100. - -<li> libtiff/tif_lzw.c: Added check for valid code lengths in LZWDecode() -and LZWDecodeCompat(). Fixes bug 115. - -<li> tif_getimage.c: Ensure that TIFFRGBAImageBegin() returns the -return code from the underlying pick function as per bug 177. - -<li> libtiff/{tif_jpeg.c,tif_strip.c,tif_print.c}: Hacked tif_jpeg.c to -fetch TIFFTAG_YCBCRSUBSAMPLING from the jpeg data stream if it isn't -present in the tiff tags as per bug 168. - -<li> libtiff/tif_jpeg.c: Fixed problem with setting of nrows in -JPEGDecode() as per bug 129. - -<li> libtiff/tif_read.c, libtiff/tif_write.c: TIFFReadScanline() and -TIFFWriteScanline() now set tif_row explicitly in case the codec has -fooled with the value as per bug 129. - -<li> libtiff/tif_ojpeg.c: Major upgrade from Scott. Details in bug 156. - -<li> libtiff/tif_open.c: Pointers to custom procedures -in TIFFClientOpen() are checked to be not NULL-pointers. - -<li> libtiff/tif_lzw.c: Assertions in LZWDecode and LZWDecodeCompat -replaced by warnings. Now libtiff should read corrupted LZW-compressed -files by skipping bad strips as per bug 100. - -<li> libtiff/: tif_dirwrite.c, tif_write.c, tiffio.h: -<a href=./man/TIFFWriteDirectory.3t.html>TIFFCheckpointDirectory()</a> -routine added as per bug 124. The -<a href=./man/TIFFWriteDirectory.3t.html>TIFFWriteDirectory</a> -man page discusses this new function as well as the related -<a href=./man/TIFFWriteDirectory.3t.html>TIFFRewriteDirectory()</a>. - -<li> libtiff/: tif_codec.c, tif_compress.c, tiffiop.h, tif_getimage.c: -Introduced -additional members tif->tif_decodestatus and tif->tif_encodestatus -for correct handling of unconfigured codecs (we should not try to read -data or to define data size without correct codecs). See bug 119. - -<li> tif_dirread.c: avoid div-by-zero if rowbytes is zero in chop func as -per bug 111. - -<li> libtiff/: tiff.h, tif_dir.c, tif_dir.h, tif_dirinfo.c, tif_dirread.c, -tif_dirwrite.c: Dwight Kelly added get/put code for new tag XMLPACKET as -defined in Adobe XMP Technote. Added missing INKSET tag value from TIFF 6.0 -spec INKSET_MULTIINK (=2). Added missing tags from Adobe TIFF technotes: -CLIPPATH, XCLIPPATHUNITS, YCLIPPATHUNITS, OPIIMAGEID, OPIPROXY and -INDEXED. Added PHOTOMETRIC tag value from TIFF technote 4 ICCLAB (=9). - -<li> libtiff/tif_getimage.c: Additional check for supported codecs added in -TIFFRGBAImageOK, TIFFReadRGBAImage, TIFFReadRGBAStrip and TIFFReadRGBATile now -use TIFFRGBAImageOK before reading a per bug 110. - -<li> libtiff/: tif_dir.c, tif_dir.h, tif_dirinfo.c, tif_dirread.c, -tif_dirwrite.c: Added routine -<a href=./man/TIFFDataWidth.3t.html>TIFFDataWidth</a> for determining -TIFFDataType sizes instead of working with tiffDataWidth array -directly as per bug 109. - -<li>libtiff/: tif_dirinfo.c, tif_dirwrite.c: Added possibility to -read broken TIFFs with LONG type used for TIFFTAG_COMPRESSION, -TIFFTAG_BITSPERSAMPLE, TIFFTAG_PHOTOMETRIC as per bug 99. - -<li> libtiff/{tiff.h,tif_fax3.c}: Add support for __arch64__ as per bug 94. - -<li> libtiff/tif_read.c: Fixed TIFFReadEncodedStrip() to fail if the -decodestrip function returns anything not greater than zero as per bug 97. - -<li> libtiff/tif_jpeg.c: fixed computation of segment_width for -tiles files to avoid error about it not matching the -cinfo.d.image_width values ("JPEGPreDecode: Improper JPEG strip/tile -size.") for ITIFF files. Apparently the problem was incorporated since -3.5.5, presumably during the OJPEG/JPEG work recently. - -<li> libtiff/tif_getimage.c: If DEFAULT_EXTRASAMPLE_AS_ALPHA is 1 -(defined in tiffconf.h - 1 by default) then the RGBA interface -will assume that a fourth extra sample is ASSOCALPHA if the -EXTRASAMPLE value isn't set for it. This changes the behaviour of -the library, but makes it work better with RGBA files produced by -lots of applications that don't mark the alpha values properly. -As per bugs 93 and 65. - -<li> libtiff/tif_jpeg.c: allow jpeg data stream sampling values to -override those from tiff directory. This makes this work with -ImageGear generated files. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!--------------------------------------------------------------------------> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> - -<li> <a href=./man/tiff2ps.1.html>tiff2ps</a>: Added page size setting -when creating PS Level 2. - -<li> <a href=./man/tiff2ps.1.html>tiff2ps</a>: Fixed PS comment emitted when -FlateDecode is being used. - -<li> <a href=./man/tiffsplit.1.html>tiffsplit</a>: increased the maximum -number of pages that can be split. - -<li> <a href=./man/raw2tiff.1.html>raw2tiff</a>: Added option `-p' to -explicitly select color space of input image data. - -<li> <a href=./man/tiffmedian.1.html>tiffmedian</a>: Suppiort for large -(> 2GB) images. - -<li> <a href=./man/ppm2tiff.1.html>ppm2tiff</a>: Fixed possible endless loop. - -<li> <a href=./man/tiff2rgba.1.html>tiff2rgba</a>: Switched to use -<A HREF="./man/TIFFReadRGBAImage.3t.html">TIFFReadRGBAImageOriented()</A> -instead of <A HREF="./man/TIFFReadRGBAImage.3t.html">TIFFReadRGBAImage()</A>. - -<li> <a href=./man/tiffcmp.1.html>tiffcmp</a>: Fixed problem with unused data -comparing (bug 349). `-z' option now can be used to set the number of reported -different bytes. - -<li> <a href=./man/tiffcp.1.html>tiffcp</a>: Added possibility to specify -value -1 to -r option to get the entire image as one strip (bug 343). - -<li> <a href=./man/tiffcp.1.html>tiffcp</a>: Set the correct RowsPerStrip -and PageNumber values (bug 343). - -<li> <a href=./man/fax2tiff.1.html>fax2tiff</a>: Page numbering fixed (bug -341). - -<li> <a href=./man/ppm2tiff.1.html>ppm2tiff</a>: PPM header parser improved: -now able to skip comments. - -<li> <a href=./man/tiff2ps.1.html>tiff2ps</a>: Force deadzone printing when -EPS output specified (bug 325). - -<li> <a href=./man/tiff2ps.1.html>tiff2ps</a>: Add ability to generate -PS Level 3. It basically allows one to use the /flateDecode filter for ZIP -compressed TIFF images. Patch supplied by Tom Kacvinsky (bug 328). - -<li> <a href=./man/tiffcp.1.html>tiffcp</a>: Fixed problem with colorspace -conversion for JPEG encoded images (bugs 23 and 275) - -<li> <a href=./man/fax2tiff.1.html>fax2tiff</a>: Applied patch from -Julien Gaulmin. More switches for fax2tiff tool for better control -of input and output (bugs 272 and 293). - -<li> <a href=./man/raw2tiff.1.html>raw2tiff</a>: -New utility for turning raw raster images into TIFF files -written by Andrey Kiselev. - -<li> <a href=./man/tiff2ps.1.html>tiff2ps</a>: -Sebastian Eken provided patches (bug 200) to add new these new -switches: - <ul> - <li> <b>-b #</b>: for a bottom margin of # inches - <li> <b>-c</b>: center image - <li> <b>-l #</b>: for a left margin of # inches - <li> <b>-r</b>: rotate the image by 180 degrees - </ul> - -Also, new features merged with code for shrinking/overlapping. - -<li> <a href=./man/tiff2ps.1.html>tiff2ps</a>: Don't emit BeginData/EndData -DSC comments since we are unable to properly include the amount to skip -as per bug 80. - -<li> <a href=./man/tiff2ps.1.html>tiff2ps</a>: Added workaround for some -software that may crash when last strip of image contains fewer number -of scanlines than specified by the `/Height' variable as per bug 164. - -<li> <a href=./man/tiff2ps.1.html>tiff2ps</a>: Patch from John Williams to add new -functionality for tiff2ps utility splitting long images in several pages as -per bug 142. New switches: - <ul> - <li> <b>-H #</b>: split image if height is more than # inches - <li> <b>-L #</b>: overLap split images by # inches - </ul> - -<li> <a href=./man/tiff2ps.1.html>tiff2ps</a>: New commandline -switches to override resolution units obtained from the input file per bug 131: - <ul> - <li> <b>-x</b>: override resolution units as centimeters - <li> <b>-y</b>: override resolution units as inches - </ul> - -<li> <a href=./man/fax2tiff.1.html>fax2tiff</a>: Updated to reflect -latest changes in libtiff per bug 125. - -<li> tiff2ps: Division by zero fixed as per bug 88. - -<li> <a href=./man/tiffcp.1.html>tiffcp<a>: -Added support for 'Orientation' tag. - -<li> <a href=./man/tiffdump.1.html>tiffdump</a>: -include TIFFTAG_JPEGTABLES in tag list. - -<li> tiffset: fix bug in error reporting. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="contrib"><B><FONT SIZE=+3>C</FONT>HANGES IN THE CONTRIB AREA:</B></A> -<UL> - -<li> Fixed distribution to include contrib/addtiffo/tif_ovrcache.{c,h}. -<li> libtiff/contrib/win95: renamed to contrib/win_dib. Added new -Tiffile.cpp example of converting TIFF files into a DIB on Win32 as per -bug 143. - -</UL> - -<!---------------------------------------------------------------------------> - -<A NAME="lzwkit"><B><FONT SIZE=+3>C</FONT>HANGES IN THE LZW COMPRESSION -KIT:</B></A> -<UL> - -<li> LZW compression kit synchronized with actual libtiff version. - -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -Last updated $Date: 2003/10/04 11:38:17 $. - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.6.1.html b/src/3rdparty/libtiff/html/v3.6.1.html deleted file mode 100644 index d106062..0000000 --- a/src/3rdparty/libtiff/html/v3.6.1.html +++ /dev/null @@ -1,199 +0,0 @@ -<HTML> -<HEAD> -<TITLE> -Changes in TIFF v3.6.1 -</TITLE> -</HEAD> - -<BODY BGCOLOR=white> -<FONT FACE="Helvetica, Arial, Sans"> -<FONT FACE="Helvetica, Arial, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.6.1<BR> -<B>Previous Version</B>: <A HREF=v3.6.0.html>v3.6.0</a><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.remotesensing.org/pub/libtiff"> -ftp.remotesensing.org</a>, directory pub/libtiff</A><BR> -<B>Master HTTP Site</B>: <A HREF="http://www.remotesensing.org/libtiff"> -http://www.remotesensing.org/libtiff</a> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#hightlights">Major Changes</A> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -<LI><A HREF="#contrib">Changes in the contrib area</A> -<LI><A HREF="#lzwkit">Changes in the LZW compression kit</A> -</UL> -<p> -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="highlights"><B><FONT SIZE=+3>M</FONT>AJOR CHANGES:</B></A> - -<ul> - <li> New utility <a href="./man/tiff2pdf.1.html">tiff2pdf</a> - for converting TIFF images directly into PDF. - <li> New <a href="./man/TIFFcolor.3t.html">color conversion module</a>. - <li> Full support for Orientation tag in - <a href="./man/TIFFReadRGBAImage.3t.html">TIFFRGBAImage</a> interface. - <li> Many bugs fixed. -</ul> - - -<P><HR WIDTH=65% ALIGN=left> -<!---------------------------------------------------------------------------> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> - -<li> libtiff/makefile.vc, tools/makefile.vc: Support for IJG JPEG library. - -<li> Makefile.in: Add an absolute path to the test_pics.sh call. - -<li> Makefile.in: Add an absolute path to the test_pics.sh call. - -<li> libtiff/tiffcomp.h: #define _BSDTYPES_DEFINED when defining BSD typedefs. - -<li> configure, libtiff/{Makefile.in, mkversion.c}: Relative buildings fixed. - -<li> Makefile.in: Add an absolute path to the test_pics.sh call. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> - -<li> libtiff/{tif_color.c, tif_getimage.c, tiffio.h}: Added support -for ReferenceBlackWhite tag handling when converted from YCbCr color space as -per bug 120. - -<li> libtiff/{tif_getimage.c, tif_aux.c}: Read WhitePoint tag from the -file and properly use it for CIE Lab 1976 to RGB transform. - -<li> libtiff/{tif_getimage.c, tiffio.h}: Finally resolved problems with -orientation handling. TIFFRGBAImage interface now properly supports all -possible orientations, i.e. images will be flipped both in horizontal and -vertical directions if required. 'Known bugs' section now removed from the -appropriate manual pages. - -<li> libtiff/tif_luv.c: Fixed bug in 48-bit to 24-bit conversion routine, -reported by Antonio Scuri. - -<li> libtiff/{tiffio.h, tif_codec.c}: Added new function -TIFFIsCODECConfigured(), suggested by Ross Finlayson. - -<li> libtiff/tif_ojpeg.c: TIFFVGetField() function now can properly extract -the fields from the OJPEG files. Patch supplied by Ross Finlayson. - -<li> libtiff/tif_dir.h: _TIFFFindOrRegisterdInfo declaration replaced -with _TIFFFindOrRegisterFieldInfo as reported by Ross Finlayson. - -<li> libtiff/tif_dirinfo.c: Implemented binary search in _TIFFMergeFieldInfo(). -Patch supplied by Ross Finlayson. - -<li> tif_dirread.c: do not mark all anonymously defined tags to be IGNOREd (as -it was done in 3.6.0). - -<li> libtiff/{tiff.h, tif_dirinfo.c}: Added support for IFD (13) datatype, -intruduced in "Adobe PageMaker TIFF Technical Notes". - -<li> libtiff/{tif_color.c, tif_getimage.c, tiffio.h}: New color space -conversion code: CIE L*a*b* 1976 images now supported by the TIFFRGBAImage -interface. YCbCr to RGB conversion code also moved there and now has -<a href="./man/TIFFcolor.3t.html">publicly available interface</a>. These -routines currently used in TIFFRGBAImage interface only and not supported in -other libtiff tools yet. So if you want, for example, to convert CIE Lab image -into PostScript file you should do it in two steps: chnge colorspace to RGB -using <a href="./man/tiff2rgba.1.html">tiff2rgba</a> utility abd then process -it with the <a href="./man/tiff2ps.1.html">tiff2ps</a>. - -<li> libtiff/tif_tile.c: Remove spurious use of "s" (sample) in the -planarconfig_contig case in TIFFComputeTile() as per bug 387 - -<li> libtiff/tiffiop.h: New macros: TIFFmax and TIFFmin. - -<li> libtiff/{tiffio.h, tif_strip.c}: Added TIFFRawStripSize() function -as suggested by Chris Hanson. - -<li> libtiff/{tif_lzw.c, tif_fax3.c}: Proper support for update mode -as per bug 424. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!--------------------------------------------------------------------------> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> - -<li> <a href=./man/tiff2pdf.1.html>tiff2pdf</a>: New tool, written by -Ross Finlayson, to directly convert TIFF files to PDF. - -<li> <a href=./man/tiffgt.1.html>tiffgt</a>: Unmaintained and platform -dependent sgigt utility removed and replaced with the completely rewritten -portable <a href=./man/tiffgt.1.html>tiffgt</a> tool (depend on OpenGL and -GLUT). This tool will not build by default. - -<li> <a href=./man/ras2tiff.1.html>ras2tiff</a>: Properly determine -SUN Rasterfiles with the reverse byte order (it is reported by the magic -header field). Problem reported by Andreas Wiesmann. - -<li> <a href=./man/raw2tiff.1.html>raw2tiff</a>: Implemented image size -guessing using correlation coefficient calculation between two neighbour -lines. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="contrib"><B><FONT SIZE=+3>C</FONT>HANGES IN THE CONTRIB AREA:</B></A> -<UL> - -<li> contrib/pds/{tif_pdsdirread.c, tif_pdsdirwrite.c}: Use TIFFDataWidth() -function insted of tiffDataWidth array. - -</UL> - -<!---------------------------------------------------------------------------> - -<A NAME="lzwkit"><B><FONT SIZE=+3>C</FONT>HANGES IN THE LZW COMPRESSION -KIT:</B></A> -<UL> - -<li> Proper support for update mode as per bug 424. - -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -Last updated $Date: 2003/12/24 22:14:15 $. - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.7.0.html b/src/3rdparty/libtiff/html/v3.7.0.html deleted file mode 100644 index 413f2c6..0000000 --- a/src/3rdparty/libtiff/html/v3.7.0.html +++ /dev/null @@ -1,144 +0,0 @@ -<HTML> -<HEAD> -<TITLE> - Changes in TIFF v3.7.0 -</TITLE> -</HEAD> - -<BODY BGCOLOR=white> -<FONT FACE="Helvetica, Arial, Sans"> -<FONT FACE="Helvetica, Arial, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.7.0<BR> -<B>Previous Version</B>: <A HREF=v3.7.0beta2.html>v3.7.0beta2</a><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.remotesensing.org/pub/libtiff"> -ftp.remotesensing.org</a>, directory pub/libtiff</A><BR> -<B>Master HTTP Site</B>: <A HREF="http://www.remotesensing.org/libtiff"> -http://www.remotesensing.org/libtiff</a> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#hightlights">Major Changes</A> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -<LI><A HREF="#contrib">Changes in the contrib area</A> -<LI><A HREF="#lzwkit">Changes in the LZW compression kit</A> -</UL> -<p> -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="highlights"><B><FONT SIZE=+3>M</FONT>AJOR CHANGES:</B></A> - -<UL> - - <li> Several bugs found after 3.7.0beta2 release were fixed. - -</UL> - - -<P><HR WIDTH=65% ALIGN=left> -<!---------------------------------------------------------------------------> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> - <li> ltmain.sh: Fix for MinGW compilation. -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> - - <li> libtiff/{tif_dirread.c, tif_jpeg.c, tif_luv.c, tif_ojpeg.c, - tif_pixarlog.c, tif_write.c}: Handle the zero strip/tile sizes - properly (Dmitry V. Levin, Marcus Meissner). - - <li> libtiff/tif_dirinfo.c: Type of the TIFFTAG_SUBIFD field changed - to TIFF_IFD. - - <li> Preliminary support for BigTIFF files: now libtiff can - recognize and reject to open such images. ;-) - - <li> libtiff/tif_dir.c: Initialize td_tilewidth and td_tilelength fields - of the TIFFDirectory structure with the 0 instead of -1 to avoid - confusing integer overflows in TIFFTileRowSize() for striped images. - - <li> libtiff/tif_dir.c: Initialize td_tilewidth and td_tilelength fields - of the TIFFDirectory structure with the 0 instead of -1 to avoid - confusing integer overflows in TIFFTileRowSize() for striped images. - - <li> libtiff/tif_dirinfo.c: Fix bug with tif_foundfield and reallocation - of tif_fieldinfo as per bug - <A HREF="http://bugzilla.remotesensing.org/show_bug.cgi?id=630"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=630</A> - - <li> libtiff/tif_compress.c: Improved error reporting in - TIFFGetConfiguredCODECs() (Dmitry V. Levin). - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!--------------------------------------------------------------------------> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> - <li> tiffcmp.c (leof): Renamed from 'eof' in order to avoid - conflict noticed under MinGW. - - <li> tiff2pdf.c: Fixed TransferFunction tag handling reported - by Ross A. Finlayson. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="contrib"><B><FONT SIZE=+3>C</FONT>HANGES IN THE CONTRIB AREA:</B></A> - -<UL> - - <li> No changes. - -</UL> - -<!---------------------------------------------------------------------------> - -<A NAME="lzwkit"><B><FONT SIZE=+3>C</FONT>HANGES IN THE LZW COMPRESSION -KIT:</B></A> -<UL> - - <li> This one is not longer needed. - -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -Last updated $Date: 2004/12/20 19:31:44 $. - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.7.0alpha.html b/src/3rdparty/libtiff/html/v3.7.0alpha.html deleted file mode 100644 index 95c633c..0000000 --- a/src/3rdparty/libtiff/html/v3.7.0alpha.html +++ /dev/null @@ -1,249 +0,0 @@ -<HTML> -<HEAD> -<TITLE> - Changes in TIFF v3.7.0alpha -</TITLE> -</HEAD> - -<BODY BGCOLOR=white> -<FONT FACE="Helvetica, Arial, Sans"> -<FONT FACE="Helvetica, Arial, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.7.0alpha<BR> -<B>Previous Version</B>: <A HREF=v3.6.1.html>v3.6.1</a><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.remotesensing.org/pub/libtiff"> -ftp.remotesensing.org</a>, directory pub/libtiff</A><BR> -<B>Master HTTP Site</B>: <A HREF="http://www.remotesensing.org/libtiff"> -http://www.remotesensing.org/libtiff</a> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#hightlights">Major Changes</A> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -<LI><A HREF="#contrib">Changes in the contrib area</A> -<LI><A HREF="#lzwkit">Changes in the LZW compression kit</A> -</UL> -<p> -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="highlights"><B><FONT SIZE=+3>M</FONT>AJOR CHANGES:</B></A> - -<ul> - <li> Significant changes in software configuration: we are switched - to GNU autotools now. - - <li> tiffset: tiffset now can set any libtiff supported tags. Tags - can be supplied by the mnemonic name or number. -</ul> - - -<P><HR WIDTH=65% ALIGN=left> -<!---------------------------------------------------------------------------> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> - <li> Get rid of the old configuration system and switch to - GNU autotools. -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> - <li> libtiff/tif_ojpeg.c: Fixed problem with duplicated SOI and SOF - markers as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=581" - http://bugzilla.remotesensing.org/show_bug.cgi?id=581</a>. - - <li> libtiff/{tif_open.c, tiffio.h}: New function added: - TIFFIsBigEndian(). Function returns nonzero if given was file written - in big-endian order. - - <li> libtiff/tif_print.c: added (untested) support for printing - SSHORT, SLONG and SRATIONAL fields. - - <li> libtiff/tif_fax3.c: Avoid reading CCITT compression options - if compression type mismatches. See - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=565"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=565</a>. - - <li> libtiff/tif_strip.c: Never return 0 from the TIFFNumberOfStrips(). - - <li> libtiff/tif_dirread.c: Workaround for broken TIFF writers which - store single SampleFormat value for multisampled images. See - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=562"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=562</a>. - - <li> libtiff/tif_write.c: Allow in-place updating of the compressed - images (don't work properly with all codecs). For details see GDAL bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=534"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=534</a>. - - <li> libtiff/tif_jpeg.c: Workaround for wrong sampling factors used - in the Intergarph JPEG compressed TIFF images as per bug: - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=532"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=532</a>. - - <li> libtiff/tif_open.c: Use dummy mmap/munmap functions in - TIFFClientOpen() when the appropriate client functions was not - supplied by user. - - <li> libtiff/tif_dirread.c: Fixed problem with handling TIFF_UNDEFINED - tag type in TIFFFetchNormalTag() as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=508" - http://bugzilla.remotesensing.org/show_bug.cgi?id=508</a>. - - <li> libtiff/tif_codec.c: Fixed typo in TIFFInitPackBits name as per: - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=494"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=494</a>. - - <li> libtiff/tif_fax3.c: Fixed problem, introdiced in 3.6.1 release, - with the CCITT encoding modes as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=483"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=483</a>. - We need more work on fax codec to support update mode. - - <li> libtiff/tiff.h: Fixed tag definitions for TIFFTAG_YCLIPPATHUNITS - and TIFFTAG_INDEXED as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=475"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=475</a>. - - <li> libtiff/{tif_win32.c, tif_unix.c}: Check whether the pointer is - NULL before proceeding further as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=474"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=474</a>. - Check results, returned by the TIFFFdOpen() before returning and close - file if TIFFFdOpen() failed as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=468"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=468</a>. - - <li> libtiff/{libtiff.def, tif_close.c, tiffio.h, tif_open.c}: - Separate TIFFCleanup() from the TIFFClose() in order to fix the bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=468"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=468</a>. - - <li> libtiff/tif_dirwrite.c: Fixed handling of writable ASCII tags - that are field_passcount=TRUE properly. Arguably anonymous custom - tags should be declared as passcount=FALSE, but I don't want to change - that without a careful review. - - <li> libtiff/tif_write.c: Fixed reporting size of the buffer in case - of stripped image in TIFFWriteBufferSetup(). As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=460"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=460</a>. - - <li> libtiff/tif_dir.c: Incomplete cleanup in TIFFFreeDirectory(), - patch from Gerben Koopmans. - - <li> libtiff/tif_dirread.c: Check field_passcount value before setting - the value of undefined type, patch from Gerben Koopmans. - - <li> libtiff/{tiff.h, tif_fax3.c}:Fixes for AMD 64 platform as - suggested by Jeremy C. Reed. - - <li> libtiff/tif_win32.c: Fixed problem with _TIFFrealloc() when - the NULL pointer passed. Patch supplied by Larry Grill. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!--------------------------------------------------------------------------> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> - <li> tiffset: tiffset now can set any libtiff supported tags. Tags - can be supplied by the mnemonic name or number. - - <li> ycbcr.c: fixed main() declaration as per: - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=513"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=513</a>. - - <li> <a href=./man/tiffsplit.1.html>tiffsplit</a>: Don't forget - to copy Photometric Interpretation tag. - - <li> <a href=./man/tiffsplit.1.html>tiffsplit</a>: Fixed problem with - unproperly written multibyte files. Now output files will be written - using the same byte order flag as in the input image. See - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=574" - http://bugzilla.remotesensing.org/show_bug.cgi?id=574</a>. - - <li> <a href=./man/tiffsplit.1.html>tiffsplit</a>: Copy JPEGTables - tag contents for JPEG compressed images. Reported by Artem Mirolubov. - - <li> <a href=./man/tiffcp.1.html>tiffcp</a>: Close output file - on normal exit. - - <li> <a href=./man/tiffcp.1.html>tiffcp</a>: Don't emit warnings - when Orientation tag does not present in the input image. - - <li> <a href=./man/tiffcp.1.html>tiffcp</a>: Properly set - Photometric Interpretation in case of JPEG compression of grayscale - images. - - <li> <a href=./man/tiffcp.1.html>tiffcp</a>: Fixed problem with wrong - interpretation of the InkNames tag as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=466"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=466</a>. - Memory leak fixed. - - <li> <a href=./man/tiffcp.1.html>tiffcp</a>: Fixed problem with - wrong Photometric setting for non-RGB images. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="contrib"><B><FONT SIZE=+3>C</FONT>HANGES IN THE CONTRIB AREA:</B></A> - -<UL> - - <li> Outdated stuff removed. - - <li> Almost all programs are sinchronized with the current libtiff - and should compile without problems. - -</UL> - -<!---------------------------------------------------------------------------> - -<A NAME="lzwkit"><B><FONT SIZE=+3>C</FONT>HANGES IN THE LZW COMPRESSION -KIT:</B></A> -<UL> - -<li> No changes. - -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -Last updated $Date: 2006/03/18 17:12:47 $. - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.7.0beta.html b/src/3rdparty/libtiff/html/v3.7.0beta.html deleted file mode 100644 index 7d7c868..0000000 --- a/src/3rdparty/libtiff/html/v3.7.0beta.html +++ /dev/null @@ -1,162 +0,0 @@ -<HTML> -<HEAD> -<TITLE> - Changes in TIFF v3.7.0beta -</TITLE> -</HEAD> - -<BODY BGCOLOR=white> -<FONT FACE="Helvetica, Arial, Sans"> -<FONT FACE="Helvetica, Arial, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.7.0beta<BR> -<B>Previous Version</B>: <A HREF=v3.7.0alpha.html>v3.7.0alpha</a><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.remotesensing.org/pub/libtiff"> -ftp.remotesensing.org</a>, directory pub/libtiff</A><BR> -<B>Master HTTP Site</B>: <A HREF="http://www.remotesensing.org/libtiff"> -http://www.remotesensing.org/libtiff</a> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#hightlights">Major Changes</A> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -<LI><A HREF="#contrib">Changes in the contrib area</A> -<LI><A HREF="#lzwkit">Changes in the LZW compression kit</A> -</UL> -<p> -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="highlights"><B><FONT SIZE=+3>M</FONT>AJOR CHANGES:</B></A> - -<ul> - <li> LZW compression enabled by default. You don't need the separate - compression kit anymore. - - <li> bmp2tiff: Added new utility to convert Windows BMP files - into TIFFs. - - <li> The first attempt to implement a test suite. -</ul> - - -<P><HR WIDTH=65% ALIGN=left> -<!---------------------------------------------------------------------------> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> - <li> Many portability fixes in the new autotooled build suite. -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> - <li> libtiff/{tif_luv.c, tif_next.c, tif_thunder.c}: Several buffer - overruns fixed, as noted by Chris Evans. - - <li> BSD data types (u_char, u_short, u_int, u_long) is no longer - used internally in the libtiff. Should result in simpler configuration - and better portability. - - <li> libtiff/tiff.h: Fix column tagging. Reference current Adobe XMP - specification. Reference libtiff bug tracking system to submit - private tag additions. - - <li> libtiff/tif_dirread.c: Don't reject to read tags of the - SamplesPerPixel size when the tag count is greater than number of - samples as per bug - <A HREF="http://bugzilla.remotesensing.org/show_bug.cgi?id=576"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=576</A>. - - <li> libtiff/{tiffio.h, tif_open.c}: Applied patches from - Joris Van Damme to avoid requirement for tiffiop.h inclusion in - some applications. Look for details here: - <A HREF="http://www.asmail.be/msg0054799560.html"> - http://www.asmail.be/msg0054799560.html</A>. - - <li> libtiff/{tiffiop.h, tif_dirinfo.c}: Fixed problem with the static - variable as per bug - <A HREF="http://bugzilla.remotesensing.org/show_bug.cgi?id=593"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=593</A>. - - <li> libtiff/tif_lzw.c: LZW compression code is merged back from the - separate package. All libtiff tools are updated to not advertise an - abcence of LZW support. - - <li> libtiff/tif_dir.c: Call TIFFError() instead of producing warnings - when setting custom tags by value. Reported by Eric Fieleke. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!--------------------------------------------------------------------------> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> - <li> tiff2ps: Avoid zero division in setupPageState() function; - properly initialize array in PSDataBW(). - - <li> tiff2pdf: Multiple bugfixes. - - <li> ras2tiff: Fixed issue with missed big-endian checks as per bug - </A HREF="http://bugzilla.remotesensing.org/show_bug.cgi?id=586"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=586</A>. - - <li> bmp2tiff: Added new utility to convert Windows BMP files - into TIFFs. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="contrib"><B><FONT SIZE=+3>C</FONT>HANGES IN THE CONTRIB AREA:</B></A> - -<UL> - - <li> No changes. - -</UL> - -<!---------------------------------------------------------------------------> - -<A NAME="lzwkit"><B><FONT SIZE=+3>C</FONT>HANGES IN THE LZW COMPRESSION -KIT:</B></A> -<UL> - - <li> This one is not longer needed. - -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -Last updated $Date: 2006/03/18 17:12:47 $. - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.7.0beta2.html b/src/3rdparty/libtiff/html/v3.7.0beta2.html deleted file mode 100644 index 67dd8da..0000000 --- a/src/3rdparty/libtiff/html/v3.7.0beta2.html +++ /dev/null @@ -1,131 +0,0 @@ -<HTML> -<HEAD> -<TITLE> - Changes in TIFF v3.7.0beta2 -</TITLE> -</HEAD> - -<BODY BGCOLOR=white> -<FONT FACE="Helvetica, Arial, Sans"> -<FONT FACE="Helvetica, Arial, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.7.0beta2<BR> -<B>Previous Version</B>: <A HREF=v3.7.0beta.html>v3.7.0beta</a><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.remotesensing.org/pub/libtiff"> -ftp.remotesensing.org</a>, directory pub/libtiff</A><BR> -<B>Master HTTP Site</B>: <A HREF="http://www.remotesensing.org/libtiff"> -http://www.remotesensing.org/libtiff</a> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#hightlights">Major Changes</A> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -<LI><A HREF="#contrib">Changes in the contrib area</A> -<LI><A HREF="#lzwkit">Changes in the LZW compression kit</A> -</UL> -<p> -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="highlights"><B><FONT SIZE=+3>M</FONT>AJOR CHANGES:</B></A> - -<UL> - - <li> The code has been reviewed by Dmitry Levin: added checks - for values, returned by the space allocation functions, fixed - problems with the possible integer overflows. - -</UL> - - -<P><HR WIDTH=65% ALIGN=left> -<!---------------------------------------------------------------------------> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> - <li> Several fixes in the test suite. -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> - - <li> Preliminary support for BigTIFF files: now libtiff can - recognize and reject to open such images. ;-) - - <li> libtiff/tif_dirinfo.c: changed type of XMLPacket (tag 700) to - TIFFTAG_BYTE instead of TIFFTAG_UNDEFINED to comply with the info - in the Adobe XMP Specification. - - <li> Added many checks for integer overflow and for successful space - allocations in the different parts of library. Code review - completed by Dmitry V. Levin. - - <li> libtiff/{tiffio.h, tif_compress.c}: Added - TIFFGetConfiguredCODECs()function to get the list of configured codecs. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!--------------------------------------------------------------------------> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> - <li> tiff2bw: Write ImageWidth/Height tags to output file, as - noted by Gennady Khokhorin. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="contrib"><B><FONT SIZE=+3>C</FONT>HANGES IN THE CONTRIB AREA:</B></A> - -<UL> - - <li> No changes. - -</UL> - -<!---------------------------------------------------------------------------> - -<A NAME="lzwkit"><B><FONT SIZE=+3>C</FONT>HANGES IN THE LZW COMPRESSION -KIT:</B></A> -<UL> - - <li> This one is not longer needed. - -</UL> - -<A HREF="index.html"><IMG SRC="images/back.gif"></A> TIFF home page.<BR> - -<HR> - -Last updated $Date: 2006/03/18 17:12:47 $. - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.7.1.html b/src/3rdparty/libtiff/html/v3.7.1.html deleted file mode 100644 index b888792..0000000 --- a/src/3rdparty/libtiff/html/v3.7.1.html +++ /dev/null @@ -1,233 +0,0 @@ -<HTML> -<HEAD> -<TITLE> - Changes in TIFF v3.7.1 -</TITLE> -</HEAD> - -<BODY BGCOLOR=white> -<FONT FACE="Helvetica, Arial, Sans"> -<FONT FACE="Helvetica, Arial, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.7.1<BR> -<B>Previous Version</B>: <A HREF=v3.7.0.html>v3.7.0</a><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.remotesensing.org/pub/libtiff"> -ftp.remotesensing.org</a>, directory pub/libtiff</A><BR> -<B>Master HTTP Site</B>: <A HREF="http://www.remotesensing.org/libtiff"> -http://www.remotesensing.org/libtiff</a> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#hightlights">Major Changes</A> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -<LI><A HREF="#contrib">Changes in the contrib area</A> -</UL> -<p> -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="highlights"><B><FONT SIZE=+3>M</FONT>AJOR CHANGES:</B></A> - -<UL> - - <li> This is mostly bugfix release. Most important fix is the one - related to wrong custom tag read/write code. - -</UL> - - -<P><HR WIDTH=65% ALIGN=left> -<!---------------------------------------------------------------------------> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> - - <li> autogen.sh: aclocal and autoheader should be executed after - libtoolize. Also add '-I .' to aclocal invocation to check - current directory for macros. - - <li> nmake.opt: Link with the user32.lib in windowed mode. As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=697"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=697</a> - - <li> nmake.opt, makefile.vc: make it easier to rename the libtiff DLL. - - <li> configure, configure.ac: Added --enable-rpath option to embed - linker paths into library binary. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> - - <li> tiff.h: Revert back libtiff data type definitions as per - bug <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=687"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=687</a> - - <li> tif_dirread.c: Do not forget about TIFF_VARIABLE2 when - checking for tag count in TIFFReadDirectory() function. As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=713"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=713</a> - - <li> tif_getimage.c: Support for multiple-alpha-channelled - RGB-images as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=718"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=718</a> - - <li> tif_getimage.c: #define A1 bracketing for clean build on - SunPro compiler. - - <li> tif_dirwrite.c: Always write TIFFTAG_SUBIFD using LONG type - as per bugs - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=703"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=703</a> and - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=704"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=704</a>. - - <li> tif_win32.c: Use char* strings instead of TCHAR in windowed - mode as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=697"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=697</a> - - <li> tif_dir.c, tif_dirread.c: Remove TIFFReassignTagToIgnore() - call from the TIFFReadDirectory() function. TIFFReassignTagToIgnore - must be removed in the future, as it was never used properly. As per - bug <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=692"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=692</a> - - <li> tif_jpeg.c: Added a work-around in order to allow - compilation with the heavily modified version of libjpeg delivered - with Cygwin. - - <li> tif_dir.c: Properly handle tags, which have the uint32 - counts. As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=693"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=693</a> - - <li> tif_unix.c: Make UNIX module compilable (and usable) - on Windows. - - <li> tiff.h: Added Adobe DNG tags. - - <li> tif_aux.c: Set the appropriate ReferenceBlackWhite array for - YCbCr image which lacks that tag (noted by Hans Petter Selasky). - - <li> tif_color.c: Division by zero fixed (Hans Petter Selasky). - - <li> tif_stream.cxx, tiffio.h: Added C++ stream interface - contributed by Edward Lam (see - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=654"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=654</a> - for details). Those who want to use C++ streams should - #include <tiffio.hxx>. - - <li> tif_open.c: Removed close() in TIFFClientOpen() if file - is bad. This is the callers responsibility. - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=651"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=651</a> - - <li> tiffio.h, tif_win32.c, libtiff.def}: Added TIFFOpenW() - function to work with the double byte strings (used to represent - filenames in some locales). As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=625"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=625</a> - - <li> tif_dirread.c: Fixed problem when fetching BitsPerSample and - Compression tags of type LONG from broken TIFFS as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=662"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=662</a> - - <li> tif_dirinfo.c: Fixed definition for TIFFTAG_RICHTIFFIPTC, - the writecount should have uint32 type. As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=662"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=662</a> - - <li> tif_write.c: Fixed wrong if() statement in - TIFFAppendToStrip() function as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=660"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=660</a> - - <li> tif_dirinfo.c: Change definition for TIFFTAG_EXTRASAMPLES - field. The caller should supply a count when setting this field. As - per bug <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=648"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=648</a>. - - <li> tif_jpeg.c, tif_ojpeg.c: TIFFTAG_JPEGTABLES should have - uint32 count. Use this type everywhere. - - <li> tif_next.c: avoid use of u_long and u_char types. - - <li> tif_fax3.c: Fixed case with the wrong decode routines - choosing when the incorrect Group4Options tag set. As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=323"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=323</a> - - <li> tif_dirwrite.c: Fixed problem with passing count variable of - wrong type when writing the TIFF_BYTE/TIFF_SBYTE tags in - TIFFWriteNormalTag(). - - <li> tif_compress.c: Zero division problem fixed (Vladimir Nadvornik, - Dmitry V. Levin). - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!--------------------------------------------------------------------------> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> - - <li> fax2ps.c: Be able to extract the first page (#0). As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=690"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=690</a> - - <li> tiff2ps.c: Fixed wrong variable data type when read Position - tags (Tristan Hill). - - <li> tiff2ps.c: Fixed wrong variable data type when read Resolution - tags (Peter Fales). - - <li> tiffset.c: Check the malloc return value (Dmitry V. Levin). - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="contrib"><B><FONT SIZE=+3>C</FONT>HANGES IN THE CONTRIB AREA:</B></A> - -<UL> - - <li> No changes. - -</UL> - -Last updated $Date: 2004/12/20 19:31:44 $. - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.7.2.html b/src/3rdparty/libtiff/html/v3.7.2.html deleted file mode 100644 index 6cb6f7c..0000000 --- a/src/3rdparty/libtiff/html/v3.7.2.html +++ /dev/null @@ -1,222 +0,0 @@ -<HTML> -<HEAD> -<TITLE> - Changes in TIFF v3.7.2 -</TITLE> -</HEAD> - -<BODY BGCOLOR=white> -<FONT FACE="Helvetica, Arial, Sans"> -<FONT FACE="Helvetica, Arial, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.7.2<BR> -<B>Previous Version</B>: <A HREF=v3.7.1.html>v3.7.1</a><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.remotesensing.org/pub/libtiff"> -ftp.remotesensing.org</a>, directory pub/libtiff</A><BR> -<B>Master HTTP Site</B>: <A HREF="http://www.remotesensing.org/libtiff"> -http://www.remotesensing.org/libtiff</a> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#hightlights">Major Changes</A> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -<LI><A HREF="#contrib">Changes in the contrib area</A> -</UL> -<p> -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="highlights"><B><FONT SIZE=+3>M</FONT>AJOR CHANGES:</B></A> - -<UL> - - <li> Maintainance release. Many bugfixes in the build environment - and compatibility improvements. - -</UL> - - -<P><HR WIDTH=65% ALIGN=left> -<!---------------------------------------------------------------------------> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> - <li> configure.ac: Use -rpath option instead of -R as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=732"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=732</a> - - <li> tif_stream.cxx: Fixes for C++ stream interface from - Michael Rinne and Edward Lam. - - <li> configure.ac: Make the documentation directory location - configurable via the --with-docdir option (as suggested by - Jeremy C. Reed). - - <li> Place the C++ stream API in the separate library called - libtiffxx to avoid unneeded dependencies. Probably there will be - more C++ API in the future. As per bugs - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=733"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=733</a> - and <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=730"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=730</a> - - <li> configure, configure.ac: Replace --disable-c++ with the - --disable-cxx option as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=730"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=730</a>. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> - - <li> Applied patch from Lee Howard to support a new tag TIFFTAG_FAXDCS - (34911) used in HylaFax software. As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=771"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=771</a> - - <li> tif_open.c: Remove unnesessary TIFFSeekFile() call as per - bug <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=756"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=756</a> - - <li> tiff.h: Changed the int8 definition to be always signed char - as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=727"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=727</a> - - <li> tiffio.h: Move TIFFOpenW() function into the extern "C"{} - block as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=763"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=763</a> - - <li> tif_dirread.c: Estimate strip size in case of wrong or - suspicious values in the tags. As per bugs - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=705"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=705</a> - and <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=320"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=320</a> - - <li> tif_color.c: Use double as the second argument of pow() - function in TIFFCIELabToRGBInit(). As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=741"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=741</a> - - <li> tif_pixarlog.c: Avoid warnings when converting float to - integer as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=740"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=740</a> - - <li> tif_getimage.c: Always fill the error message buffer in - TIFFRGBAImageBegin() as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=739"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=739</a> - - <li> tif_jpeg.c: Added ability to read/write the fax specific - TIFFTAG_FAXRECVPARAMS, TIFFTAG_FAXSUBADDRESS and TIFFTAG_FAXRECVTIME - tags as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=736"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=736</a> - - <li> tif_win32.c: Fixed message formatting in functions - Win32WarningHandler() and Win32ErrorHandler() as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=735"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=735</a> - - <li> tiffio.h: Move the color conversion routines in the 'extern - "C"' section as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=727"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=727</a> - - <li> tiff.h: Restore back the workaround for AIX Visual Age C - compiler to avoid double definition of BSD types as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=39"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=39</a> - - <li> tif_getimage.c: More fixes for multiple-alpha-channelled - RGB-images as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=713"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=713</a> - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!--------------------------------------------------------------------------> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> - - <li> tiffcmp.c: Added ability to compare the 32-bit integer and - floating point data; complain on unsupported bit depths. - - <li> tiffcmp.c: Use properly sized buffer in short arrays comparison - as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=785"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=785</a> - - <li> fax2ps.c: Replace insecure mktemp() function with the - tmpfile() as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=786"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=786</a> - - <li> tiffgt.c: Fix problem on big-endian CPUs so that images - display more correctly. Images display brighter than they should - on a Sun workstation. - - <li> tiff2ps.c: Fixed problem with page sizes as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=742"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=742</a> - - <li> tiff2ps.c: Interpret the -w and -h options independently. As - per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=689"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=689</a> - - <li> tiffdump.c: Fixed problem when read broken TIFFs with the - wrong tag counts (Dmitry V. Levin, Martin Pitt). - - <li> tiffset.c: Convert character option to integer value as per - bug <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=725"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=725</a>. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="contrib"><B><FONT SIZE=+3>C</FONT>HANGES IN THE CONTRIB AREA:</B></A> - -<UL> - - <li> No changes. - -</UL> - -Last updated $Date: 2005/03/15 15:17:44 $. - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.7.3.html b/src/3rdparty/libtiff/html/v3.7.3.html deleted file mode 100644 index d698451..0000000 --- a/src/3rdparty/libtiff/html/v3.7.3.html +++ /dev/null @@ -1,230 +0,0 @@ -<HTML> -<HEAD> -<TITLE> - Changes in TIFF v3.7.3 -</TITLE> -</HEAD> - -<BODY BGCOLOR=white> -<FONT FACE="Helvetica, Arial, Sans"> -<FONT FACE="Helvetica, Arial, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.7.3<BR> -<B>Previous Version</B>: <A HREF=v3.7.2.html>v3.7.2</a><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.remotesensing.org/pub/libtiff"> -ftp.remotesensing.org</a>, directory pub/libtiff</A><BR> -<B>Master HTTP Site</B>: <A HREF="http://www.remotesensing.org/libtiff"> -http://www.remotesensing.org/libtiff</a> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#hightlights">Major Changes</A> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -<LI><A HREF="#contrib">Changes in the contrib area</A> -</UL> -<p> -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="highlights"><B><FONT SIZE=+3>M</FONT>AJOR CHANGES:</B></A> - -<UL> - <li> Replace runtime endianess check with the compile time one. - - <li> Added support for the new predictor type (floating point - predictor), defined at the TIFF Technical Note 3. - - <li> Added Support for custom tags, passed by value. - Added support for all DNG tags. -</UL> - - -<P><HR WIDTH=65% ALIGN=left> -<!---------------------------------------------------------------------------> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> - <li> Do not use empty -R option when linking with --enable-rpath. - - <li> Added workaround for OpenBSD/MirOS soname problem as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=838"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=838</a> - - <li> Fixed parallel compilation of the libtiff and - libtiffxx libraries as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=826"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=826</a> - - <li> configure.ac, libtiff/Makefile.am: Use libtool machinery to pass - rpath option. - - <li> make.opt: Build with Win32 CRT library by default. -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> - <li> tiffiop.h, tif_open.c: Added open option 'h' to avoid reading - the first IFD when needed. As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=875"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=875</a> - - <li> tiff.h: Use correct int size on Sparc 64bit/Sun compiler - platform. As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=855"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=855</a> - - <li> tif_dirinfo.c: Added support for ClipPath, XClipPathUnits - and YClipPathUnits tags. - - <li> tif_dirinfo.c, tif_dir.h, tif_dir.c, tif_print.c: Make - DocumentName, Artist, HostComputer, ImageDescription, Make, Model, - Copyright, DateTime, PageName, TextureFormat, TextureWrapModes and - TargetPrinter tags custom. - - <li> tif_jpeg.c: Cleanup the codec state depending on TIFF_CODERSETUP - flag (to fix memory leaks). - - <li> tif_dirwrite.c: Use tdir_count when calling - TIFFCvtNativeToIEEEDouble() in the TIFFWriteDoubleArray() function as - per bug <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=845"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=845</a> - - <li> tif_dirinfo.c, tif_print.c: TIFFFetchByteArray() returns - uint16 array when fetching the BYTE and SBYTE fields, so we should - consider result as pointer to uint16 array and not as array of chars. - As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=831"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=831</a> - - <li> tif_dir.c: More efficient custom tags retrieval as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=830"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=830</a> - - <li> tif_win32.c: Use FILE_SHARE_READ | FILE_SHARE_WRITE share - mode in CreateFile() call as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=829"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=829</a> - - <li> tif_jpeg.c: Substantial fix for addtiffo problems with - JPEG encoded TIFF files. Pre-allocate lots of space for jpegtables - in directory. - - <li> tif_dirread.c: Changed the code that computes - stripbytecount[0] if it appears bogus to ignore if stripoffset[0] is - zero. This is a common case with GDAL indicating a "null" tile/strip. - - <li> tif_jpeg.c: added LIB_JPEG_MK1 support in JPEGDecodeRaw(). - - <li> tif_dirread.c: Ensure that broken files with too many - values in PerSampleShorts, TIFFFetchPerSampleLongs and - TIFFFetchPerSampleAnys work ok instead of crashing. - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=843"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=843</a> - - <li> tif_predict.h, tif_predict.c: Added ability to decode and encode - floating point predictor, as per TIFF Technical Note 3. - See http://chriscox.org/TIFF_TN3_Draft2.pdf for details. - - <li> tiffio.h, tiffiop.h, tif_dir.c, tif_read.c, tif_swab.c: - Added _TIFFSwab24BitData() and TIFFSwabArrayOfLong() functions used to - swap 24-bit floating point values. - - <li> tiff.h: Added predictor constants. - - <li> tiffiop.h, tif_dir.c: Use uint32 type for appropriate values - in _TIFFVSetField() function. Inspired by the bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=816"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=816</a> - - <li> tif_open.c: Do not read header in case the output file should - be truncated (Ron). - - <li> tif_dirinfo.c, tif_config.h.vc: Use lfind() instead of bsearch() - in _TIFFFindFieldInfoByName() function (Ron). - - <li> tif_dir.c, tif_print.c: Properly handle all data types in custom - tags. - - <li> dirinfo.c: Added DNG tags. - - <li> tiff.h: Added missed DNG tag (LensInfo); added DNG 1.1.0.0 tags. - - <li> tif_dir.c, tif_print.c: Added Support for custom tags, passed - by value. - - <li> tiff.h, tif_dirinfo.c, tiffiop.h: Added EXIF related tags. -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!--------------------------------------------------------------------------> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> - <li> tiff2pdf.c: Print two characters per loop in the - t2p_write_pdf_trailer(). As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=594"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=594</a> - - <li> tiffgt.c: Use MacOS X OpenGL framework when appropriate. As - per bug <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=844"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=844</a> - - <li> ppm2tiff.c: Fixed format string when read PPM file header with - the fscanf() function. As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=861"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=861</a> - - <li> tiffsplit.c: Check for JPEGTables tag presence before copying. - - <li> tiff2pdfr.c: Calculate the tile width properly; added new - option '-b' to use interpolation in output PDF files (Bruno Ledoux). - - <li> tiffdither.c: Copy the PhotometricInterpretation tag from the - input file. - - <li> tif2pdf.c: Fixed problem with alpha channel handling as per - bug <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=794"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=794</a>. -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="contrib"><B><FONT SIZE=+3>C</FONT>HANGES IN THE CONTRIB AREA:</B></A> - -<UL> - - <li> addtiffo/{tif_overview.c, tif_ovrcache.c, tif_ovrcache.h}: - Make overviews working for contiguous images. - -</UL> - -Last updated $Date: 2006/01/04 22:04:46 $. - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.7.4.html b/src/3rdparty/libtiff/html/v3.7.4.html deleted file mode 100644 index 9437320..0000000 --- a/src/3rdparty/libtiff/html/v3.7.4.html +++ /dev/null @@ -1,133 +0,0 @@ -<HTML> -<HEAD> -<TITLE> - Changes in TIFF v3.7.4 -</TITLE> -</HEAD> - -<BODY BGCOLOR=white> -<FONT FACE="Helvetica, Arial, Sans"> -<FONT FACE="Helvetica, Arial, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.7.4<BR> -<B>Previous Version</B>: <A HREF=v3.7.3.html>v3.7.3</a><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.remotesensing.org/pub/libtiff"> -ftp.remotesensing.org</a>, directory pub/libtiff</A><BR> -<B>Master HTTP Site</B>: <A HREF="http://www.remotesensing.org/libtiff"> -http://www.remotesensing.org/libtiff</a> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#hightlights">Major Changes</A> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -<LI><A HREF="#contrib">Changes in the contrib area</A> -</UL> -<p> -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="highlights"><B><FONT SIZE=+3>M</FONT>AJOR CHANGES:</B></A> - -<UL> - <li> Fixed important bug in custom tags handling code.. -</UL> - - -<P><HR WIDTH=65% ALIGN=left> -<!---------------------------------------------------------------------------> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> - <li> Applied patch from Patrick Welche (all scripts moved in the - 'config' and 'm4' directories). - - <li> SConstruct, libtiff/SConstruct: Added the first very preliminary - support for SCons software building tool (http://www.scons.org/). - This is experimental infrastructure and it will exist along with the - autotools stuff. - - <li> port/lfind.c: Added lfind() replacement module. -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> - <li> tif_dir.c: When prefreeing tv->value in TIFFSetFieldV - also set it to NULL to avoid double free when re-setting custom - string fields as per: - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=922"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=922</a> - - <li> tif_dir.c: Fixed up support for swapping "double complex" - values (128 bits as 2 64 bits doubles). GDAL gcore tests now - pass on bigendian (macosx) system. - - <li> libtiff/{tif_dirread.c, tif_dirinfo.c}: Do not upcast BYTEs to - SHORTs in the TIFFFetchByteArray(). Remove TIFFFetchExtraSamples() - function, use TIFFFetchNormalTag() instead as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=831"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=831</a> - - Remove TIFFFetchExtraSamples() function, use TIFFFetchNormalTag() - instead. - - <li> tif_print.c: Fixed printing of the BYTE and SBYTE arrays. - - <li> tif_write.c: Do not check the PlanarConfiguration field in - the TIFFWriteCheck() function in case of single band images (as per - TIFF spec). - - <li> libtiff/{tif_dir.c, tif_dir.h, tif_dirinfo.c, tif_print.c}: - Make FieldOfViewCotangent, MatrixWorldToScreen, MatrixWorldToCamera, - ImageFullWidth, ImageFullLength and PrimaryChromaticities tags custom. -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!--------------------------------------------------------------------------> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> - <li> tiffcp.c: Fixed WhitePoint tag copying. -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="contrib"><B><FONT SIZE=+3>C</FONT>HANGES IN THE CONTRIB AREA:</B></A> - -<UL> - <li> tiffdump.c: Added support for TIFF_IFD datatype. - - <li> addtiffo/{tif_overview.c, tif_ovrcache.c, tif_ovrcache.h}: - Make overviews working for contiguous images. - -</UL> - -Last updated $Date: 2005/11/03 14:18:43 $. - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.8.0.html b/src/3rdparty/libtiff/html/v3.8.0.html deleted file mode 100644 index 914dcb0..0000000 --- a/src/3rdparty/libtiff/html/v3.8.0.html +++ /dev/null @@ -1,199 +0,0 @@ -<HTML> -<HEAD> -<TITLE> - Changes in TIFF v3.8.0 -</TITLE> -</HEAD> - -<BODY BGCOLOR=white> -<FONT FACE="Helvetica, Arial, Sans"> -<FONT FACE="Helvetica, Arial, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.8.0<BR> -<B>Previous Version</B>: <A HREF=v3.7.4.html>v3.7.4</a><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.remotesensing.org/pub/libtiff"> -ftp.remotesensing.org</a>, directory pub/libtiff</A><BR> -<B>Master HTTP Site</B>: <A HREF="http://www.remotesensing.org/libtiff"> -http://www.remotesensing.org/libtiff</a> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#hightlights">Major Changes</A> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -<LI><A HREF="#contrib">Changes in the contrib area</A> -</UL> -<p> -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="highlights"><B><FONT SIZE=+3>M</FONT>AJOR CHANGES:</B></A> - -<UL> - <li> Read-only support for custom directories (e.g. EXIF directory). - - <li> Preliminary support for MS MDI format. -</UL> - - -<P><HR WIDTH=65% ALIGN=left> -<!---------------------------------------------------------------------------> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> - <li> Make the default strip size configurable via the - --with-default-strip-size and STRIP_SIZE_DEFAULT options. -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> - <li> tiffio.h: Added VC_EXTRALEAN definition before including - windows.h, to reduce the compile time. - - <li> tif_jpeg.c: Improve compilation under MinGW. - - <li> {tif_aux.c, tif_dir.c, tif_dir.h, tif_dirwrite.c, - tif_print.c, tif_getimage.c}: Make InkSet, NumberOfInks, DotRange and - StoNits tags custom. - - <li> {tif_aux.c, tif_dir.c, tif_dir.h, tif_print.c}: Make - WhitePoint tag custom. - - <li> tiffio.h: fixed typo that potentially resulted in - redefininition of USE_WIN32_FILEIO - - <li> {tif_dir.c, tif_dir.h, tif_print.c}: Make RichTIFFIPTC, - Photoshop and ICCProfile tags custom. - - <li> libtiff/*, contrib/*: Added 'dual-mode' error handling, enabling - newer code to get context indicator in error handler and still - remain compatible with older code: Done TIFFError calls everywhere - except in tools. - - <li> tiffinfo.c: Print EXIF directory contents if exist. - - <li> {tif_dirinfo.c, tif_dirread.c, tif_dir.h, tif_dir.c}: - Custom directory read-only support. - - <li> {tif_aux.c, tif_dirinfo.c, tif_dirread.c, tif_dir.h, - tif_dir.c, tif_print.c}: Make YCbCrCoefficients and ReferenceBlackWhite - tags custom. - - <li> tif_dirread.c: One more workaround for broken StripByteCounts - tag. Handle the case when StripByteCounts array filled with - completely wrong values. - - <li> tif_dirinfo.c: Release file descriptor in case of failure - in the TIFFOpenW() function as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1003"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1003</a> - - <li> tif_dirinfo.c: Correctly yse bsearch() and lfind() - functions as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1008"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1008</a> - - <li> tif_open.c, tiff.h, tiffdump.c: Incorporate preliminary support - for MS MDI format. - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1002"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1002</a> - - <li> libtiff.def, tiffiop.h, tiffio.h: Made TIFFFreeDirectory - public. - - <li> /tif_dirinfo.c: Make XResolution, YResolution and - ResolutionUnit tags modifiable during write process. As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=977"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=977</a> - - <li> if_dirread.c: Don't try and split single strips into "0" strips - in ChopUpSingleUncompressedStrip. This happens in some degenerate - cases (like 1x1 files with stripbytecounts==0 (gtsmall.jp2 embed tiff) - - <li> tif_fax3.c: changed 'at scanline ...' style warning/errors - with incorrect use of tif_row, to 'at line ... of - strip/tile ...' style. -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!--------------------------------------------------------------------------> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> - <li> tiffcp.c: Added many error reporting messages; fixed integer - overflow as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=789"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=789</a> - - <li> tiffcp.c: Return non-zero status when reading fails. - - <li> fax2tiff.c: Properly calculate sizes of temporary arrays - as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=943"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=943</a> - - <li> fax2tiff.c: Added option '-r' to set RowsPerStrip parameter - as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=944"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=944</a> - - <li> tiffdump.c: Fixed typeshift and typemask arrays initialization - problem as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=946"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=946</a> - - <li> bmp2tiff.c: Fixed possible integer overflow error as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=965"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=965</a> - - <li> tiffsplit.c: Copy fax related fields over splitted parts - as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=983"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=983</a> - - <li> tiffdump.c: Fixed crash when reading malformed tags. - - <li> tiff2pdf.c: Added missed 'break' statement as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=932"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=932</a> -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="contrib"><B><FONT SIZE=+3>C</FONT>HANGES IN THE CONTRIB AREA:</B></A> - -<UL> - <li> contrib/addtiffo/*: Major upgrade by Joris to support subsampled - YCbCr images in jpeg compressed TIFF files. - -</UL> - -Last updated $Date: 2006/01/04 23:38:38 $. - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.8.1.html b/src/3rdparty/libtiff/html/v3.8.1.html deleted file mode 100644 index 9fea140..0000000 --- a/src/3rdparty/libtiff/html/v3.8.1.html +++ /dev/null @@ -1,217 +0,0 @@ -<HTML> -<HEAD> -<TITLE> - Changes in TIFF v3.8.1 -</TITLE> -</HEAD> - -<BODY BGCOLOR=white> -<FONT FACE="Helvetica, Arial, Sans"> -<FONT FACE="Helvetica, Arial, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.8.1<BR> -<B>Previous Version</B>: <A HREF=v3.8.0.html>v3.8.0</a><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.remotesensing.org/pub/libtiff"> -ftp.remotesensing.org</a>, directory pub/libtiff</A><BR> -<B>Master HTTP Site</B>: <A HREF="http://www.remotesensing.org/libtiff"> -http://www.remotesensing.org/libtiff</a> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#hightlights">Major Changes</A> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -<LI><A HREF="#contrib">Changes in the contrib area</A> -</UL> -<p> -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="highlights"><B><FONT SIZE=+3>M</FONT>AJOR CHANGES:</B></A> - -<UL> - <li> Bug-fix release. -</UL> - - -<P><HR WIDTH=65% ALIGN=left> -<!---------------------------------------------------------------------------> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> - <li> libtool related stuff updated from the 2.1a branch. - - <li> Fix with_default_strip_size comparison as reported by - Norihiko Murase. -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> - - <li> tif_dirread.c: Fixed error reporting in TIFFFetchAnyArray() - function as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1102"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1102</a> - - <li> tif_jpeg.c, tif_pixarlog.c, tif_fax3.c, tif_zip.c: - Properly restore setfield/getfield methods in cleanup functions. As - per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1102"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1102</a> - - <li> tif_lzw.c, tif_pixarlog.c, tif_zip.c: Use - TIFFPredictorCleanup() in codec cleanup methods. As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1102"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1102</a> - - <li> tif_predict.c, tif_predict.h: Added new function - TIFFPredictorCleanup() to restore parent decode/encode/field methods. - - <li> tif_dirread.c: Fixed integer overflow condition in - TIFFFetchData() function. As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1102"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1102</a> - - <li> tif_ojpeg.c: Set the ReferenceBlackWhite with the - TIFFSetField() method, not directly. As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1043"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1043</a> - - <li> tif_write.c: Small code rearrangement in TIFFWriteScanline() - to avoid crash as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1081"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1081</a> - - <li> tif_dirwrite.c: Properly write TIFFTAG_DOTRANGE tag as per - bug <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1088"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1088</a> - - <li> tif_print.c: Properly read TIFFTAG_PAGENUMBER, - TIFFTAG_HALFTONEHINTS, TIFFTAG_YCBCRSUBSAMPLING and TIFFTAG_DOTRANGE - tags as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1088"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1088</a> - - <li> tif_tile.c: Fix error reporting in TIFFCheckTile() as per - bug <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1063"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1063</a> - - <li> tif_color.c: Avoid overflow in case of wrong input as per - bug <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1065"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1065</a> - - <li> tif_dirinfo.c: Use TIFF_NOTYPE instead of 0 when - appropriate. As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1033"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1033</a> - - <li> tif_aux.c: Fixed type of temporary variable in - _TIFFCheckMalloc() as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=103"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=103</a> - - <li> tif_aux.c: Return static array when fetching default - YCbCrCoefficients (another problem, reported a the - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1029"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1029</a> - entry). - - <li> tif_dir.c: Special handling for PageNumber, HalftoneHints, - YCbCrSubsampling and DotRange tags as per bugs - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1029"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1029</a> - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1034"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1034</a> - - <li> tif_dirread.c: Use _TIFFGetExifFieldInfo() instead of - _TIFFGetFieldInfo() in TIFFReadEXIFDirectory() call as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1026"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1026</a> - - <li> tif_dirinfo.c: Change definitions for TIFFTAG_ICCPROFILE, - TIFFTAG_PHOTOSHOP, TIFFTAG_RICHTIFFIPTC, TIFFTAG_XMLPACKET: - readcount should be uint32 value. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!--------------------------------------------------------------------------> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> - <li> ppm2tiff.c: Added support for PBM files as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1044"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1044</a> - - <li> tiff2pdf.c: Functions t2p_sample_rgbaa_to_rgb() and - t2p_sample_rgba_to_rgb() was used in place of each other, that was - resulted in problems with RGBA images with associated alpha. - As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1097"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1097</a> - - <li> tiff2ps.c: Properly scale all the pages when converting - multipage TIFF with /width/height/center options set. As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1080"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1080</a> - - <li> tiff2pdf.c: Do not create output file until all option checks - will be done. As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1072"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1072</a> - - <li> bmp2tiff.c: Added ability to create multipage TIFFs from the - list of input files as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1077"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1077</a> - - <li> tiffgt.c: Avoid crashing in case of image unsupported by - TIFFRGBAImage interface. - - <li> tiff2pdf.c: Fixed support for non-YCbCr encoded JPEG - compressed TIFF files, per submission from Dan Cobra. - - <li> bmp2tiff, pal2rgb, ppm2tiff, ras2tiff, raw2tiff, sgi2tiff, - tiff2bw, tiffcp: Fixed jpeg option processing so -c jpeg:r:50 works - properly as per bug: - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1025"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1025</a> - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="contrib"><B><FONT SIZE=+3>C</FONT>HANGES IN THE CONTRIB AREA:</B></A> - -<UL> -</UL> - -Last updated $Date: 2006/03/13 14:52:12 $. - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.8.2.html b/src/3rdparty/libtiff/html/v3.8.2.html deleted file mode 100644 index e648127..0000000 --- a/src/3rdparty/libtiff/html/v3.8.2.html +++ /dev/null @@ -1,137 +0,0 @@ -<HTML> -<HEAD> -<TITLE> - Changes in TIFF v3.8.2 -</TITLE> -</HEAD> - -<BODY BGCOLOR=white> -<FONT FACE="Helvetica, Arial, Sans"> -<FONT FACE="Helvetica, Arial, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.8.2<BR> -<B>Previous Version</B>: <A HREF=v3.8.1.html>v3.8.1</a><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.remotesensing.org/pub/libtiff"> -ftp.remotesensing.org</a>, directory pub/libtiff</A><BR> -<B>Master HTTP Site</B>: <A HREF="http://www.remotesensing.org/libtiff"> -http://www.remotesensing.org/libtiff</a> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#hightlights">Major Changes</A> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -<LI><A HREF="#contrib">Changes in the contrib area</A> -</UL> -<p> -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="highlights"><B><FONT SIZE=+3>M</FONT>AJOR CHANGES:</B></A> - -<UL> - <li> Bug-fix release. -</UL> - - -<P><HR WIDTH=65% ALIGN=left> -<!---------------------------------------------------------------------------> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> - - <li> tools/Makefile.am: Use runtime paths linker flags when rpath - option enabled. - - <li> Makefiles improvements as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1128"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1128</a> - - <li> Fixed win32 I/O functions usage as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1127"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1127</a> - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> - <li> tif_strip.c: Take subsampling in account when calculating - TIFFScanlineSize(). - - <li> tif_jpeg.c, tif_fax3.c, tif_zip.c, tif_pixarlog.c, - tif_lzw.c, tif_luv.c: Use _TIFFSetDefaultCompressionState() in all - codec cleanup methods. As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1120"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1120</a> - - <li> tif_jpeg.c: Do not cleanup codec state in TIFFInitJPEG(). As - per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1119"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1119</a> - - <li> tif_dir.c: Use double type instead of dblparam_t. - - <li> tif_dirread.c: Do not check the PlanarConfig tag presence - in TIFFReadDirectory, because it is always set at the start of - function and we allow TIFFs without that tag set. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!--------------------------------------------------------------------------> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> - <li> tiffcp.c: Do not set RowsPerStrip bigger than image length. - - <li> fax2tiff.c: Fixed wrong TIFFerror() invocations as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1125"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1125</a> - - <li> fax2ps.c: Fixed reading the input stream from stdin as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1124"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1124</a> - - <li> raw2tiff.c: Do not set RowsPerStrip larger than ImageLength. - As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1110"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1110</a> - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="contrib"><B><FONT SIZE=+3>C</FONT>HANGES IN THE CONTRIB AREA:</B></A> - -<UL> -</UL> - -Last updated $Date: 2006/03/23 14:54:01 $. - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.9.0beta.html b/src/3rdparty/libtiff/html/v3.9.0beta.html deleted file mode 100644 index 053b34a..0000000 --- a/src/3rdparty/libtiff/html/v3.9.0beta.html +++ /dev/null @@ -1,304 +0,0 @@ -<HTML> -<HEAD> -<TITLE> - Changes in TIFF v3.9.0beta -</TITLE> -</HEAD> - -<BODY BGCOLOR=white> -<FONT FACE="Helvetica, Arial, Sans"> -<FONT FACE="Helvetica, Arial, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.9.0beta<BR> -<B>Previous Version</B>: <A HREF=v3.8.2.html>v3.8.2</a><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.remotesensing.org/pub/libtiff"> -ftp.remotesensing.org</a>, directory pub/libtiff</A><BR> -<B>Master HTTP Site</B>: <A HREF="http://www.remotesensing.org/libtiff"> -http://www.remotesensing.org/libtiff</a> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). -If you don't find something listed here, then it was not done in this -timeframe, or it was not considered important enough to be mentioned. -The following information is located here: -<UL> -<LI><A HREF="#hightlights">Major Changes</A> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -<LI><A HREF="#contrib">Changes in the contrib area</A> -</UL> -<p> -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="highlights"><B><FONT SIZE=+3>M</FONT>AJOR CHANGES:</B></A> - -<UL> - <li> New <b>tiffcrop</b> utility contributed by Richard Nolde. - <b>tiffcrop</b> does the same as <b>tiffcp</b>, but also can crop, - extract, rotate and mirror images. - - <li> tif_jbig.c: Added support for JBIG compression scheme - (34661 code), contributed by Lee Howard. - - <li> Totally new implementation of OJPEG module from - Joris Van Damme. No need to patch libjpeg anymore. Many OJPEG files - should be supported now that was not supported previously. - -</UL> - - -<P><HR WIDTH=65% ALIGN=left> -<!---------------------------------------------------------------------------> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> - - <li> tif_config.wince.h, tiffconf.wince.h, tif_wince.c: WinCE-specific - compatibility stuff from Mateusz Loskot. - - <li> Rename config.h.vc and tif_config.h.vc to config.vc.h and - tif_config.vc.h for easier identification by folks using an IDE. - - <li> configure, configure.ac: OJPEG support enabled by default (i.e., - whe the conformant JPEG support enabled). - - <li> README.vms, Makefile.am, configure.com, libtiff/{Makefile.am, - tif_config.h-vms, tif_stream.cxx, tif_vms.c, tiffconf.h-vms}: - Added support for OpenVMS by Alexey Chupahin. - - <li> nmake.opt: use /EHsc for VS2005 compatibility. Also define - _CRT_SECURE_NO_DEPRECATE to avoid noise on VS2005. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> - <li> tif_dirinfo.c (_TIFFFindFieldInfo): Don't attempt to - bsearch() on a NULL fieldinfo list. - (_TIFFFindFieldInfoByName): Don't attempt to lfind() on a NULL - fieldinfo list. - - <li> tif_jpeg.c: Changed JPEGInitializeLibJPEG() so that it - will convert from decompressor to compressor or compress to decompress - if required by the force arguments. This works around a problem in - where the JPEGFixupTestSubsampling() may cause a decompressor to - be setup on a directory when later a compressor is required with the - force flag set. Occurs with the addtiffo program for instance. - - <li> tif_dirwrite.c: Fixed swapping of byte arrays stored - in-place in tag offsets as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1363"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1363</a> - - <li> tif_getimage.c: workaround for 'Fractional scanline' error - reading OJPEG images with rowsperstrip that is not a multiple of - vertical subsampling factor. This bug is mentioned in - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1390"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1390</a> and - <a href="http://www.asmail.be/msg0054766825.html"> - http://www.asmail.be/msg0054766825.html</a> - - <li> tif_dirread.c: Added special function to handle - SubjectDistance EXIF tag as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1362"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1362</a> - - <li> tif_dirread.c, tif_read.c: Type of the byte counters - changed from tsize_t to uint32 to be able to work with data arrays - larger than 2GB. Fixes bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=890"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=89</a> - Idea submitted by Matt Hancher. - - <li> tif_dir.c: Workaround for incorrect TIFFs with - ExtraSamples == 999 produced by Corel Draw. As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1490"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1490</a> - - <li> tif_write.c: TIFFAppendToStrip() - clear sorted flag if - we move a strip. - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1359"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1359</a> - - <li> tif_fax3.c: Save the state of printdir codec dependent method. - - <li> tif_jpeg.c: Save the state of printdir codec dependent method - as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1273"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1273</a> - - <li> tif_win32.c: Fixed problem with offset value manipulation - as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1322"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1322</a> - - <li> tif_fax3.c, tif_next.c, tif_pixarlog.c: Fixed multiple - vulnerabilities, as per Gentoo bug (): - <a href="http://bugs.gentoo.org/show_bug.cgi?id=142383"> - http://bugs.gentoo.org/show_bug.cgi?id=142383</a> - - <li> tif_lzw.c, tif_zip.c: Fixed problems with mixing - encoding and decoding on the same read-write TIFF handle. The LZW - code can now maintain encode and decode state at the same time. The - ZIP code will switch back and forth as needed. - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=757"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=757</a> - - <li> tif_msdos.c: Avoid handle leak for failed opens. - c/o Thierry Pierron - - <li> tif_dirwrite.c: take care not to flush out buffer of strip/tile - data in _TIFFWriteDirectory if TIFF_BEENWRITING not set. Relates - to bug report by Peng Gao with black strip at bottom of images. - - <li> tif_dirwrite.c: make sure to use uint32 for wordcount in - TIFFWriteNormanTag if writecount is VARIABLE2 for ASCII fields. - It already seems to have been done for other field types. Needed - for "tiffset" on files with geotiff ascii text. - - <li> tif_dirinfo.c: Added missed EXIF tag ColorSpace (40961). - - <li> tif_dirread.c: Move IFD fetching code in the separate - function TIFFFetchDirectory() avoiding code duplication in - TIFFReadDirectory() and TIFFReadCustomDirectory(). - - <li>tif_readdir.c: Added case in EstimateStripByteCounts() for tiled - files. Modified TIFFReadDirectory() to not invoke - EstimateStripByteCounts() for case where entry 0 and 1 are unequal but - one of them is zero. - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1204"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1204</a> - - <li> tif_open.c, tif_dirread.c, tiffiop.h: Move IFD looping - checking code in the separate function TIFFCheckDirOffset(). - - <li> tif_aux.c: Added _TIFFCheckRealloc() function. - - <li> tif_fax3.c: Fixed problems in fax decoder as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1194"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1194</a> - - <li> tif_jbig.c: Added support for JBIG compression scheme - (34661 code) contributed by Lee Howard. As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=896"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=896</a> - - <li> tif_getimage.c: Added support for planarconfig separate - non-subsampled YCbCr (i.e. separate YCbCr with subsampling [1,1]). - - <li> tif_getimage.c: Revision of all RGB(A) put routines: - <ul> - <li> Conversion of unassociated alpha to associated alpha - now done with more performant LUT, and calculation more - correct. - <li> Conversion of 16bit data to 8bit data now done with - more performant LUT, and calculation more correct - <li> Bugfix of handling of 16bit RGB with unassociated alpha - </ul> - - <li> tif_ojpeg.c: totally new implementation - - <li> tif_getimage.c: removed TIFFTAG_JPEGCOLORMODE handling - of OJPEG images in favor of tif_getimage.c native handling of - YCbCr and desubsampling. - - <li> tif_jpeg.c: JPEGVSetField() so that altering the photometric - interpretation causes the "upsampled" flag to be recomputed. Fixes - peculiar bug where photometric flag had to be set before jpegcolormode - flag. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!--------------------------------------------------------------------------> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> - <li> tiff2ps.c: Added support 16-bit images as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1566"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1566</a>. - Patch from William Bader. - - <li> tiff2pdf.c: Fix for TIFFTAG_JPEGTABLES tag fetching and - significant upgrade of the whole utility as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1560"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1560</a>. - Now we don't need tiffiop.h in tiff2pdf anymore and will open output - PDF file using TIFFClientOpen() machinery as it is implemented - by Leon Bottou. - - <li> tiffcrop.c: New tiffcrop utility contributed - by Richard Nolde. As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1383"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1383</a> - - <li> tiff2pdf.c: Do not assume inches when the resolution units - do not specified. As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1366"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1366</a> - - <li> tiffset.c: Properly handle tags with TIFF_VARIABLE writecount. - As per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1350"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1350</a> - - <li> tif2rgba.c: This utility does not work properly on big-endian - architectures. It was fixed including the bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1149"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1149</a> - - <li> tiff2pdf.c: Fix handling of -q values. - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=587"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=587</a> - - <li> tiffcmp.c: Fixed floating point comparison logic as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1191"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1191</a> - - <li> tiff2pdf.c: Fixed buffer overflow condition in - t2p_write_pdf_string() as per bug - <a href="http://bugzilla.remotesensing.org/show_bug.cgi?id=1196"> - http://bugzilla.remotesensing.org/show_bug.cgi?id=1196</a> - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="contrib"><B><FONT SIZE=+3>C</FONT>HANGES IN THE CONTRIB AREA:</B></A> - -<UL> - - <li> contrib/addtiffo/tif_overview.c: Fix problems with odd sized - output blocks in TIFF_DownSample_Subsampled() (bug 1542). - - <li> contrib/dbs/xtiff/xtiff.c: Make xtiff utility compilable. - Though it is still far from the state of being working and useful. - -</UL> - -Last updated $Date: 2007/07/13 13:40:12 $. - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.9.1.html b/src/3rdparty/libtiff/html/v3.9.1.html deleted file mode 100644 index 9322848..0000000 --- a/src/3rdparty/libtiff/html/v3.9.1.html +++ /dev/null @@ -1,115 +0,0 @@ -<HTML> -<HEAD> -<TITLE> - Changes in TIFF v3.9.1 -</TITLE> -</HEAD> - -<BODY BGCOLOR=white> -<FONT FACE="Helvetica, Arial, Sans"> -<FONT FACE="Helvetica, Arial, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.9.1<BR> -<B>Previous Version</B>: <A HREF=v3.9.1.html>v3.9.1</a><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.remotesensing.org/pub/libtiff"> -ftp.remotesensing.org</a>, directory pub/libtiff</A><BR> -<B>Master HTTP Site</B>: <A HREF="http://www.remotesensing.org/libtiff"> -http://www.remotesensing.org/libtiff</a> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). If you don't -find something listed here, then it was not done in this timeframe, or -it was not considered important enough to be mentioned. The following -information is located here: -<UL> -<LI><A HREF="#hightlights">Major Changes</A> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -<LI><A HREF="#contrib">Changes in the contrib area</A> -</UL> -<p> -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="highlights"><B><FONT SIZE=+3>M</FONT>AJOR CHANGES:</B></A> - -<UL> - <li> This is a bug-fix release for several bugs (two of which - are dire) which were discovered in the 3.9.0 release. - -</UL> - - -<P><HR WIDTH=65% ALIGN=left> -<!---------------------------------------------------------------------------> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> - - <li> Several defines were missing from tif_config.vc.h which - are necessary to compile the library using MSVC. - - <li> Colorized tests were actually not enabled as expected. - Parallel tests mode is now also enabled so that tests can be - run in parallel, and test output is sent to .log files. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> - <li> libtiff/tif_write.c (TIFFAppendToStrip): Remove cast - which caused libtiff to output a wrong last strip with - byte-count and strip-offset of zero. This cast was added on - the day of the 3.9.0 release. - - <li> libtiff/tif_dirwrite.c: Back out changes from 2007-11-22 - that resulted in the final strip not being written in some - circumstances. - http://bugzilla.maptools.org/show_bug.cgi?id=2088 - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!--------------------------------------------------------------------------> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> - <li> None - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="contrib"><B><FONT SIZE=+3>C</FONT>HANGES IN THE CONTRIB AREA:</B></A> - -<UL> - - <li> None - -</UL> - -Last updated $Date: 2009-08-28 18:49:02 $. - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/html/v3.9.2.html b/src/3rdparty/libtiff/html/v3.9.2.html deleted file mode 100644 index 2f390c8..0000000 --- a/src/3rdparty/libtiff/html/v3.9.2.html +++ /dev/null @@ -1,122 +0,0 @@ -<HTML> -<HEAD> -<TITLE> - Changes in TIFF v3.9.2 -</TITLE> -</HEAD> - -<BODY BGCOLOR=white> -<FONT FACE="Helvetica, Arial, Sans"> -<FONT FACE="Helvetica, Arial, Sans"> - -<BASEFONT SIZE=4> -<B><FONT SIZE=+3>T</FONT>IFF <FONT SIZE=+2>C</FONT>HANGE <FONT SIZE=+2>I</FONT>NFORMATION</B> -<BASEFONT SIZE=3> - -<UL> -<HR SIZE=4 WIDTH=65% ALIGN=left> -<B>Current Version</B>: v3.9.2<BR> -<B>Previous Version</B>: <A HREF=v3.9.1.html>v3.9.1</a><BR> -<B>Master FTP Site</B>: <A HREF="ftp://ftp.remotesensing.org/pub/libtiff"> -ftp.remotesensing.org</a>, directory pub/libtiff</A><BR> -<B>Master HTTP Site</B>: <A HREF="http://www.remotesensing.org/libtiff"> -http://www.remotesensing.org/libtiff</a> -<HR SIZE=4 WIDTH=65% ALIGN=left> -</UL> - -<P> -This document describes the changes made to the software between the -<I>previous</I> and <I>current</I> versions (see above). If you don't -find something listed here, then it was not done in this timeframe, or -it was not considered important enough to be mentioned. The following -information is located here: -<UL> -<LI><A HREF="#hightlights">Major Changes</A> -<LI><A HREF="#configure">Changes in the software configuration</A> -<LI><A HREF="#libtiff">Changes in libtiff</A> -<LI><A HREF="#tools">Changes in the tools</A> -<LI><A HREF="#contrib">Changes in the contrib area</A> -</UL> -<p> -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="highlights"><B><FONT SIZE=+3>M</FONT>AJOR CHANGES:</B></A> - -<UL> - - <li> Fixes a number of bugs present in the 3.9.1 release. - - <li> OJPEG support updated to work with IJG JPEG 7 release. - - <li> Tiffcrop validated for most TIFF storage subformats and sample depths. - -</UL> - - -<P><HR WIDTH=65% ALIGN=left> -<!---------------------------------------------------------------------------> - -<A NAME="configure"><B><FONT SIZE=+3>C</FONT>HANGES IN THE SOFTWARE CONFIGURATION:</B></A> - -<UL> - - <li> x86_64 now uses the same default fill order as i386. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="libtiff"><B><FONT SIZE=+3>C</FONT>HANGES IN LIBTIFF:</B></A> - -<UL> - <li> Writing tags with an array value of type TIFF_DOUBLE now - returns correct error status. The TIFFTAG_SMINSAMPLEVALUE and - TIFFTAG_SMAXSAMPLEVALUE tags failed to write without this fix. - - <li> OJPEG decoder now works with IJG JPEG 7. Resolves "Bug - 2090 - OJPEG crash with libjpeg v7". - http://bugzilla.maptools.org/show_bug.cgi?id=2090 - - <li> Eliminate most GCC "dereferencing type-punned pointer" - warnings. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!--------------------------------------------------------------------------> - -<A NAME="tools"><B><FONT SIZE=+3>C</FONT>HANGES IN THE TOOLS:</B></A> - -<UL> - - <li> New tiffcrop from Richard Nolde. Major updates to add - significant functionality for reading and writing tile based - images with bit depths not a multiple of 8 which cannot be - handled by tiffcp. - - <li> Allow building tools with GCC using the "-Wformat - -Werror=format-security" flags. - -</UL> - -<P><HR WIDTH=65% ALIGN=left> - -<!---------------------------------------------------------------------------> - -<A NAME="contrib"><B><FONT SIZE=+3>C</FONT>HANGES IN THE CONTRIB AREA:</B></A> - -<UL> - - <li> None - -</UL> - -Last updated $Date: 2009-08-28 18:49:02 $. - -</BODY> -</HTML> diff --git a/src/3rdparty/libtiff/libtiff/libtiff.def b/src/3rdparty/libtiff/libtiff/libtiff.def index 3caefd8..892ad23 100644 --- a/src/3rdparty/libtiff/libtiff/libtiff.def +++ b/src/3rdparty/libtiff/libtiff/libtiff.def @@ -12,12 +12,19 @@ EXPORTS TIFFOpen TIFFGetTagListEntry TIFFGetTagListCount TIFFReadDirectory + TIFFScanlineSize64 TIFFScanlineSize + TIFFStripSize64 TIFFStripSize + TIFFVStripSize64 TIFFVStripSize + TIFFRawStripSize64 TIFFRawStripSize + TIFFTileRowSize64 TIFFTileRowSize + TIFFTileSize64 TIFFTileSize + TIFFVTileSize64 TIFFVTileSize TIFFFileno TIFFSetFileno @@ -86,17 +93,20 @@ EXPORTS TIFFOpen TIFFWriteEncodedTile TIFFWriteRawTile TIFFSetWriteOffset + TIFFSwabFloat TIFFSwabDouble TIFFSwabShort TIFFSwabLong TIFFSwabArrayOfShort TIFFSwabArrayOfLong + TIFFSwabArrayOfFloat TIFFSwabArrayOfDouble TIFFSwabArrayOfTriples TIFFReverseBits TIFFGetBitRevTable TIFFDefaultStripSize TIFFDefaultTileSize + TIFFRasterScanlineSize64 TIFFRasterScanlineSize _TIFFmalloc _TIFFrealloc @@ -104,13 +114,17 @@ EXPORTS TIFFOpen _TIFFmemset _TIFFmemcpy _TIFFmemcmp + _TIFFCheckMalloc TIFFCreateDirectory TIFFSetTagExtender - TIFFMergeFieldInfo - TIFFFindFieldInfo - TIFFFindFieldInfoByName TIFFFieldWithName TIFFFieldWithTag + TIFFFieldTag + TIFFFieldName + TIFFFieldDataType + TIFFFieldPassCount + TIFFFieldReadCount + TIFFFieldWriteCount TIFFCurrentDirOffset TIFFWriteCheck TIFFRGBAImageOK @@ -137,4 +151,8 @@ EXPORTS TIFFOpen TIFFAccessTagMethods TIFFGetClientInfo TIFFSetClientInfo - TIFFReassignTagToIgnore + TIFFSwabLong8 + TIFFSwabArrayOfLong8 + TIFFFindField + TIFFUnsetField + TIFFMergeFieldInfo diff --git a/src/3rdparty/libtiff/libtiff/mkg3states.c b/src/3rdparty/libtiff/libtiff/mkg3states.c index dd29ec8..1df9ccc 100644 --- a/src/3rdparty/libtiff/libtiff/mkg3states.c +++ b/src/3rdparty/libtiff/libtiff/mkg3states.c @@ -1,4 +1,4 @@ -/* "$Id: mkg3states.c,v 1.10 2007/02/22 11:27:17 dron Exp $ */ +/* "$Id: mkg3states.c,v 1.11 2010-03-10 18:56:48 bfriesen Exp $ */ /* * Copyright (c) 1991-1997 Sam Leffler @@ -442,3 +442,10 @@ main(int argc, char* argv[]) } /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/t4.h b/src/3rdparty/libtiff/libtiff/t4.h index 10bb17a..b908f54 100644 --- a/src/3rdparty/libtiff/libtiff/t4.h +++ b/src/3rdparty/libtiff/libtiff/t4.h @@ -1,26 +1,26 @@ -/* $Id: t4.h,v 1.1.1.1 1999/07/27 21:50:27 mike Exp $ */ +/* $Id: t4.h,v 1.3 2010-03-10 18:56:48 bfriesen Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * - * Permission to use, copy, modify, distribute, and sell this software and + * 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. - * + * + * 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 + * 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. */ @@ -33,18 +33,18 @@ * worthwhile to make code & length 8 bits. */ typedef struct tableentry { - unsigned short length; /* bit length of g3 code */ - unsigned short code; /* g3 code */ - short runlen; /* run length in bits */ + unsigned short length; /* bit length of g3 code */ + unsigned short code; /* g3 code */ + short runlen; /* run length in bits */ } tableentry; -#define EOL 0x001 /* EOL code value - 0000 0000 0000 1 */ +#define EOL 0x001 /* EOL code value - 0000 0000 0000 1 */ /* status values returned instead of a run length */ -#define G3CODE_EOL -1 /* NB: ACT_EOL - ACT_WRUNT */ -#define G3CODE_INVALID -2 /* NB: ACT_INVALID - ACT_WRUNT */ -#define G3CODE_EOF -3 /* end of input data */ -#define G3CODE_INCOMP -4 /* incomplete run code */ +#define G3CODE_EOL -1 /* NB: ACT_EOL - ACT_WRUNT */ +#define G3CODE_INVALID -2 /* NB: ACT_INVALID - ACT_WRUNT */ +#define G3CODE_EOF -3 /* end of input data */ +#define G3CODE_INCOMP -4 /* incomplete run code */ /* * Note that these tables are ordered such that the @@ -279,7 +279,14 @@ const tableentry TIFFFaxBlackCodes[] = { { 12, 0x0, G3CODE_INVALID }, /* 0000 0000 0000 */ }; #else -extern const tableentry TIFFFaxWhiteCodes[]; -extern const tableentry TIFFFaxBlackCodes[]; +extern const tableentry TIFFFaxWhiteCodes[]; +extern const tableentry TIFFFaxBlackCodes[]; #endif #endif /* _T4_ */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_acorn.c b/src/3rdparty/libtiff/libtiff/tif_acorn.c deleted file mode 100644 index 478390f..0000000 --- a/src/3rdparty/libtiff/libtiff/tif_acorn.c +++ /dev/null @@ -1,519 +0,0 @@ -/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_acorn.c,v 1.2 2005/12/21 12:23:13 joris Exp $ */ - -/* - * Copyright (c) 1988-1997 Sam Leffler - * Copyright (c) 1991-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. - */ - -/* - * TIFF Library RISC OS specific Routines. - * Developed out of the Unix version. - * Peter Greenham, May 1995 - */ -#include "tiffiop.h" -#include <stdio.h> -#include <stdlib.h> - -/* -Low-level file handling -~~~~~~~~~~~~~~~~~~~~~~~ -The functions in osfcn.h are unavailable when compiling under C, as it's a -C++ header. Therefore they have been implemented here. - -Now, why have I done it this way? - -The definitive API library for RISC OS is Jonathan Coxhead's OSLib, which -uses heavily optimised ARM assembler or even plain inline SWI calls for -maximum performance and minimum runtime size. However, I don't want to make -LIBTIFF need that to survive. Therefore I have also emulated the functions -using macros to _swi() and _swix() defined in the swis.h header, and -borrowing types from kernel.h, which is less efficient but doesn't need any -third-party libraries. - */ - -#ifdef INCLUDE_OSLIB - -#include "osfile.h" -#include "osgbpb.h" -#include "osargs.h" -#include "osfind.h" - -#else - -/* OSLIB EMULATION STARTS */ - -#include "kernel.h" -#include "swis.h" - -/* From oslib:types.h */ -typedef unsigned int bits; -typedef unsigned char byte; -#ifndef TRUE -#define TRUE 1 -#endif -#ifndef FALSE -#define FALSE 0 -#endif -#ifndef NULL -#define NULL 0 -#endif -#ifndef SKIP -#define SKIP 0 -#endif - -/* From oslib:os.h */ -typedef _kernel_oserror os_error; -typedef byte os_f; - -/* From oslib:osfile.h */ -#undef OS_File -#define OS_File 0x8 - -/* From oslib:osgbpb.h */ -#undef OS_GBPB -#define OS_GBPB 0xC -#undef OSGBPB_Write -#define OSGBPB_Write 0x2 -#undef OSGBPB_Read -#define OSGBPB_Read 0x4 - -extern os_error *xosgbpb_write (os_f file, - byte *data, - int size, - int *unwritten); -extern int osgbpb_write (os_f file, - byte *data, - int size); - -#define xosgbpb_write(file, data, size, unwritten) \ - (os_error*) _swix(OS_GBPB, _IN(0)|_IN(1)|_IN(2)|_IN(3)|_IN(4)|_OUT(3), \ - OSGBPB_WriteAt, \ - file, \ - data, \ - size, \ - unwritten) - -#define osgbpb_write(file, data, size) \ - _swi(OS_GBPB, _IN(0)|_IN(1)|_IN(2)|_IN(3)|_RETURN(3), \ - OSGBPB_Write, \ - file, \ - data, \ - size) - -extern os_error *xosgbpb_read (os_f file, - byte *buffer, - int size, - int *unread); -extern int osgbpb_read (os_f file, - byte *buffer, - int size); - -#define xosgbpb_read(file, buffer, size, unread) \ - (os_error*) _swix(OS_GBPB, _IN(0)|_IN(1)|_IN(2)|_IN(3)|_OUT(3), \ - OSGBPB_Read, \ - file, \ - buffer, \ - size, \ - unread) - -#define osgbpb_read(file, buffer, size) \ - _swi(OS_GBPB, _IN(0)|_IN(1)|_IN(2)|_IN(3)|_RETURN(3), \ - OSGBPB_Read, \ - file, \ - buffer, \ - size) - -/* From oslib:osfind.h */ -#undef OS_Find -#define OS_Find 0xD -#undef OSFind_Openin -#define OSFind_Openin 0x40 -#undef OSFind_Openout -#define OSFind_Openout 0x80 -#undef OSFind_Openup -#define OSFind_Openup 0xC0 -#undef OSFind_Close -#define OSFind_Close 0x0 - -#define xosfind_open(reason, file_name, path, file) \ - (os_error*) _swix(OS_Find, _IN(0)|_IN(1)|_IN(2)|_OUT(0), \ - reason, file_name, path, file) - -#define osfind_open(reason, file_name, path) \ - (os_f) _swi(OS_Find, _IN(0)|_IN(1)|_IN(2)|_RETURN(0), \ - reason, file_name, path) - -extern os_error *xosfind_openin (bits flags, - char *file_name, - char *path, - os_f *file); -extern os_f osfind_openin (bits flags, - char *file_name, - char *path); - -#define xosfind_openin(flags, file_name, path, file) \ - xosfind_open(flags | OSFind_Openin, file_name, path, file) - -#define osfind_openin(flags, file_name, path) \ - osfind_open(flags | OSFind_Openin, file_name, path) - -extern os_error *xosfind_openout (bits flags, - char *file_name, - char *path, - os_f *file); -extern os_f osfind_openout (bits flags, - char *file_name, - char *path); - -#define xosfind_openout(flags, file_name, path, file) \ - xosfind_open(flags | OSFind_Openout, file_name, path, file) - -#define osfind_openout(flags, file_name, path) \ - osfind_open(flags | OSFind_Openout, file_name, path) - -extern os_error *xosfind_openup (bits flags, - char *file_name, - char *path, - os_f *file); -extern os_f osfind_openup (bits flags, - char *file_name, - char *path); - -#define xosfind_openup(flags, file_name, path, file) \ - xosfind_open(flags | OSFind_Openup, file_name, path, file) - -#define osfind_openup(flags, file_name, path) \ - osfind_open(flags | OSFind_Openup, file_name, path) - -extern os_error *xosfind_close (os_f file); -extern void osfind_close (os_f file); - -#define xosfind_close(file) \ - (os_error*) _swix(OS_Find, _IN(0)|_IN(1), \ - OSFind_Close, \ - file) - -#define osfind_close(file) \ - (void) _swi(OS_Find, _IN(0)|_IN(1), \ - OSFind_Close, \ - file) - -/* From oslib:osargs.h */ -#undef OS_Args -#define OS_Args 0x9 -#undef OSArgs_ReadPtr -#define OSArgs_ReadPtr 0x0 -#undef OSArgs_SetPtr -#define OSArgs_SetPtr 0x1 -#undef OSArgs_ReadExt -#define OSArgs_ReadExt 0x2 - -extern os_error *xosargs_read_ptr (os_f file, - int *ptr); -extern int osargs_read_ptr (os_f file); - -#define xosargs_read_ptr(file, ptr) \ - (os_error*) _swix(OS_Args, _IN(0)|_IN(1)|_OUT(2), \ - OSArgs_ReadPtr, \ - file, \ - ptr) - -#define osargs_read_ptr(file) \ - _swi(OS_Args, _IN(0)|_IN(1)|_RETURN(2), \ - OSArgs_ReadPtr, \ - file) - -extern os_error *xosargs_set_ptr (os_f file, - int ptr); -extern void osargs_set_ptr (os_f file, - int ptr); - -#define xosargs_set_ptr(file, ptr) \ - (os_error*) _swix(OS_Args, _IN(0)|_IN(1)|_IN(2), \ - OSArgs_SetPtr, \ - file, \ - ptr) - -#define osargs_set_ptr(file, ptr) \ - (void) _swi(OS_Args, _IN(0)|_IN(1)|_IN(2), \ - OSArgs_SetPtr, \ - file, \ - ptr) - -extern os_error *xosargs_read_ext (os_f file, - int *ext); -extern int osargs_read_ext (os_f file); - -#define xosargs_read_ext(file, ext) \ - (os_error*) _swix(OS_Args, _IN(0)|_IN(1)|_OUT(2), \ - OSArgs_ReadExt, \ - file, \ - ext) - -#define osargs_read_ext(file) \ - _swi(OS_Args, _IN(0)|_IN(1)|_RETURN(2), \ - OSArgs_ReadExt, \ - file) - -/* OSLIB EMULATION ENDS */ - -#endif - -#ifndef __osfcn_h -/* Will be set or not during tiffcomp.h */ -/* You get this to compile under C++? Please say how! */ - -extern int open(const char* name, int flags, int mode) -{ - /* From what I can tell, should return <0 for failure */ - os_error* e = (os_error*) 1; /* Cheeky way to use a pointer eh? :-) */ - os_f file = (os_f) -1; - - flags = flags; - - switch(mode) - { - case O_RDONLY: - { - e = xosfind_openin(SKIP, name, SKIP, &file); - break; - } - case O_WRONLY: - case O_RDWR|O_CREAT: - case O_RDWR|O_CREAT|O_TRUNC: - { - e = xosfind_openout(SKIP, name, SKIP, &file); - break; - } - case O_RDWR: - { - e = xosfind_openup(SKIP, name, SKIP, &file); - break; - } - } - if (e) - { - file = (os_f) -1; - } - return (file); -} - -extern int close(int fd) -{ - return ((int) xosfind_close((os_f) fd)); -} - -extern int write(int fd, const char *buf, int nbytes) -{ - /* Returns number of bytes written */ - return (nbytes - osgbpb_write((os_f) fd, (const byte*) buf, nbytes)); -} - -extern int read(int fd, char *buf, int nbytes) -{ - /* Returns number of bytes read */ - return (nbytes - osgbpb_read((os_f) fd, (byte*) buf, nbytes)); -} - -extern off_t lseek(int fd, off_t offset, int whence) -{ - int absolute = 0; - - switch (whence) - { - case SEEK_SET: - { - absolute = (int) offset; - break; - } - case SEEK_CUR: - { - absolute = osargs_read_ptr((os_f) fd) + (int) offset; - break; - } - case SEEK_END: - { - absolute = osargs_read_ext((os_f) fd) + (int) offset; - break; - } - } - - osargs_set_ptr((os_f) fd, absolute); - - return ((off_t) osargs_read_ptr((os_f) fd)); -} -#endif - -static tsize_t -_tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size) -{ - return ((tsize_t) read((int) fd, buf, (size_t) size)); -} - -static tsize_t -_tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size) -{ - return ((tsize_t) write((int) fd, buf, (size_t) size)); -} - -static toff_t -_tiffSeekProc(thandle_t fd, toff_t off, int whence) -{ - return ((toff_t) lseek((int) fd, (off_t) off, whence)); -} - -static int -_tiffCloseProc(thandle_t fd) -{ - return (close((int) fd)); -} - -static toff_t -_tiffSizeProc(thandle_t fd) -{ - return (lseek((int) fd, SEEK_END, SEEK_SET)); -} - -#ifdef HAVE_MMAP -#error "I didn't know Acorn had that!" -#endif - -/* !HAVE_MMAP */ -static int -_tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) -{ - (void) fd; (void) pbase; (void) psize; - return (0); -} - -static void -_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size) -{ - (void) fd; (void) base; (void) size; -} - -/* - * Open a TIFF file descriptor for read/writing. - */ -TIFF* -TIFFFdOpen(int fd, const char* name, const char* mode) -{ - TIFF* tif; - - tif = TIFFClientOpen(name, mode, - (thandle_t) fd, - _tiffReadProc, _tiffWriteProc, - _tiffSeekProc, _tiffCloseProc, _tiffSizeProc, - _tiffMapProc, _tiffUnmapProc); - if (tif) - { - tif->tif_fd = fd; - } - return (tif); -} - -/* - * Open a TIFF file for read/writing. - */ -TIFF* -TIFFOpen(const char* name, const char* mode) -{ - static const char module[] = "TIFFOpen"; - int m, fd; - - m = _TIFFgetMode(mode, module); - - if (m == -1) - { - return ((TIFF*) 0); - } - - fd = open(name, 0, m); - - if (fd < 0) - { - TIFFErrorExt(0, module, "%s: Cannot open", name); - return ((TIFF *)0); - } - return (TIFFFdOpen(fd, name, mode)); -} - -void* -_TIFFmalloc(tsize_t s) -{ - return (malloc((size_t) s)); -} - -void -_TIFFfree(tdata_t p) -{ - free(p); -} - -void* -_TIFFrealloc(tdata_t p, tsize_t s) -{ - return (realloc(p, (size_t) s)); -} - -void -_TIFFmemset(tdata_t p, int v, tsize_t c) -{ - memset(p, v, (size_t) c); -} - -void -_TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c) -{ - memcpy(d, s, (size_t) c); -} - -int -_TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c) -{ - return (memcmp(p1, p2, (size_t) c)); -} - -static void -acornWarningHandler(const char* module, const char* fmt, va_list ap) -{ - if (module != NULL) - { - fprintf(stderr, "%s: ", module); - } - fprintf(stderr, "Warning, "); - vfprintf(stderr, fmt, ap); - fprintf(stderr, ".\n"); -} -TIFFErrorHandler _TIFFwarningHandler = acornWarningHandler; - -static void -acornErrorHandler(const char* module, const char* fmt, va_list ap) -{ - if (module != NULL) - { - fprintf(stderr, "%s: ", module); - } - vfprintf(stderr, fmt, ap); - fprintf(stderr, ".\n"); -} -TIFFErrorHandler _TIFFerrorHandler = acornErrorHandler; diff --git a/src/3rdparty/libtiff/libtiff/tif_apple.c b/src/3rdparty/libtiff/libtiff/tif_apple.c deleted file mode 100644 index 47e0e07..0000000 --- a/src/3rdparty/libtiff/libtiff/tif_apple.c +++ /dev/null @@ -1,274 +0,0 @@ -/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_apple.c,v 1.3 2005/12/21 12:23:13 joris Exp $ */ - -/* - * Copyright (c) 1988-1997 Sam Leffler - * Copyright (c) 1991-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. - */ - -/* - * TIFF Library Macintosh-specific routines. - * - * These routines use only Toolbox and high-level File Manager traps. - * They make no calls to the THINK C "unix" compatibility library. Also, - * malloc is not used directly but it is still referenced internally by - * the ANSI library in rare cases. Heap fragmentation by the malloc ring - * buffer is therefore minimized. - * - * O_RDONLY and O_RDWR are treated identically here. The tif_mode flag is - * checked in TIFFWriteCheck(). - * - * Create below fills in a blank creator signature and sets the file type - * to 'TIFF'. It is much better for the application to do this by Create'ing - * the file first and TIFFOpen'ing it later. - * --------- - * This code has been "Carbonized", and may not work with older MacOS versions. - * If so, grab the tif_apple.c out of an older libtiff distribution, like - * 3.5.5 from www.libtiff.org. - */ - -#include "tiffiop.h" -#include <Errors.h> -#include <Files.h> -#include <Memory.h> -#include <Script.h> - -#if defined(__PPCC__) || defined(__SC__) || defined(__MRC__) || defined(applec) -#define CtoPstr c2pstr -#endif - -static tsize_t -_tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size) -{ - return (FSRead((short) fd, (long*) &size, (char*) buf) == noErr ? - size : (tsize_t) -1); -} - -static tsize_t -_tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size) -{ - return (FSWrite((short) fd, (long*) &size, (char*) buf) == noErr ? - size : (tsize_t) -1); -} - -static toff_t -_tiffSeekProc(thandle_t fd, toff_t off, int whence) -{ - long fpos, size; - - if (GetEOF((short) fd, &size) != noErr) - return EOF; - (void) GetFPos((short) fd, &fpos); - - switch (whence) { - case SEEK_CUR: - if (off + fpos > size) - SetEOF((short) fd, off + fpos); - if (SetFPos((short) fd, fsFromMark, off) != noErr) - return EOF; - break; - case SEEK_END: - if (off > 0) - SetEOF((short) fd, off + size); - if (SetFPos((short) fd, fsFromStart, off + size) != noErr) - return EOF; - break; - case SEEK_SET: - if (off > size) - SetEOF((short) fd, off); - if (SetFPos((short) fd, fsFromStart, off) != noErr) - return EOF; - break; - } - - return (toff_t)(GetFPos((short) fd, &fpos) == noErr ? fpos : EOF); -} - -static int -_tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) -{ - return (0); -} - -static void -_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size) -{ -} - -static int -_tiffCloseProc(thandle_t fd) -{ - return (FSClose((short) fd)); -} - -static toff_t -_tiffSizeProc(thandle_t fd) -{ - long size; - - if (GetEOF((short) fd, &size) != noErr) { - TIFFErrorExt(fd, "_tiffSizeProc", "%s: Cannot get file size"); - return (-1L); - } - return ((toff_t) size); -} - -/* - * Open a TIFF file descriptor for read/writing. - */ -TIFF* -TIFFFdOpen(int fd, const char* name, const char* mode) -{ - TIFF* tif; - - tif = TIFFClientOpen(name, mode, (thandle_t) fd, - _tiffReadProc, _tiffWriteProc, _tiffSeekProc, _tiffCloseProc, - _tiffSizeProc, _tiffMapProc, _tiffUnmapProc); - if (tif) - tif->tif_fd = fd; - return (tif); -} - -static void ourc2pstr( char* inString ) -{ - int sLen = strlen( inString ); - BlockMoveData( inString, &inString[1], sLen ); - inString[0] = sLen; -} - -/* - * Open a TIFF file for read/writing. - */ -TIFF* -TIFFOpen(const char* name, const char* mode) -{ - static const char module[] = "TIFFOpen"; - Str255 pname; - FInfo finfo; - short fref; - OSErr err; - FSSpec fSpec; - - strcpy((char*) pname, name); - ourc2pstr((char*) pname); - - err = FSMakeFSSpec( 0, 0, pname, &fSpec ); - - switch (_TIFFgetMode(mode, module)) { - default: - return ((TIFF*) 0); - case O_RDWR | O_CREAT | O_TRUNC: - if (FSpGetFInfo(&fSpec, &finfo) == noErr) - FSpDelete(&fSpec); - /* fall through */ - case O_RDWR | O_CREAT: - if ((err = FSpGetFInfo(&fSpec, &finfo)) == fnfErr) { - if (FSpCreate(&fSpec, ' ', 'TIFF', smSystemScript) != noErr) - goto badCreate; - if (FSpOpenDF(&fSpec, fsRdWrPerm, &fref) != noErr) - goto badOpen; - } else if (err == noErr) { - if (FSpOpenDF(&fSpec, fsRdWrPerm, &fref) != noErr) - goto badOpen; - } else - goto badOpen; - break; - case O_RDONLY: - if (FSpOpenDF(&fSpec, fsRdPerm, &fref) != noErr) - goto badOpen; - break; - case O_RDWR: - if (FSpOpenDF(&fSpec, fsRdWrPerm, &fref) != noErr) - goto badOpen; - break; - } - return (TIFFFdOpen((int) fref, name, mode)); -badCreate: - TIFFErrorExt(0, module, "%s: Cannot create", name); - return ((TIFF*) 0); -badOpen: - TIFFErrorExt(0, module, "%s: Cannot open", name); - return ((TIFF*) 0); -} - -void -_TIFFmemset(tdata_t p, int v, tsize_t c) -{ - memset(p, v, (size_t) c); -} - -void -_TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c) -{ - memcpy(d, s, (size_t) c); -} - -int -_TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c) -{ - return (memcmp(p1, p2, (size_t) c)); -} - -tdata_t -_TIFFmalloc(tsize_t s) -{ - return (NewPtr((size_t) s)); -} - -void -_TIFFfree(tdata_t p) -{ - DisposePtr(p); -} - -tdata_t -_TIFFrealloc(tdata_t p, tsize_t s) -{ - Ptr n = p; - - SetPtrSize(p, (size_t) s); - if (MemError() && (n = NewPtr((size_t) s)) != NULL) { - BlockMove(p, n, GetPtrSize(p)); - DisposePtr(p); - } - return ((tdata_t) n); -} - -static void -appleWarningHandler(const char* module, const char* fmt, va_list ap) -{ - if (module != NULL) - fprintf(stderr, "%s: ", module); - fprintf(stderr, "Warning, "); - vfprintf(stderr, fmt, ap); - fprintf(stderr, ".\n"); -} -TIFFErrorHandler _TIFFwarningHandler = appleWarningHandler; - -static void -appleErrorHandler(const char* module, const char* fmt, va_list ap) -{ - if (module != NULL) - fprintf(stderr, "%s: ", module); - vfprintf(stderr, fmt, ap); - fprintf(stderr, ".\n"); -} -TIFFErrorHandler _TIFFerrorHandler = appleErrorHandler; diff --git a/src/3rdparty/libtiff/libtiff/tif_atari.c b/src/3rdparty/libtiff/libtiff/tif_atari.c deleted file mode 100644 index a519fa4..0000000 --- a/src/3rdparty/libtiff/libtiff/tif_atari.c +++ /dev/null @@ -1,243 +0,0 @@ -/* "$Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_atari.c,v 1.2 2005/12/21 12:23:13 joris Exp $" */ - -/* - * Copyright (c) 1988-1997 Sam Leffler - * Copyright (c) 1991-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. - */ - -/* - * TIFF Library ATARI-specific Routines. - */ -#include "tiffiop.h" -#if defined(__TURBOC__) -#include <tos.h> -#include <stdio.h> -#else -#include <osbind.h> -#include <fcntl.h> -#endif - -#ifndef O_ACCMODE -#define O_ACCMODE 3 -#endif - -#include <errno.h> - -#define AEFILNF -33 - -static tsize_t -_tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size) -{ - long r; - - r = Fread((int) fd, size, buf); - if (r < 0) { - errno = (int)-r; - r = -1; - } - return r; -} - -static tsize_t -_tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size) -{ - long r; - - r = Fwrite((int) fd, size, buf); - if (r < 0) { - errno = (int)-r; - r = -1; - } - return r; -} - -static toff_t -_tiffSeekProc(thandle_t fd, off_t off, int whence) -{ - char buf[256]; - long current_off, expected_off, new_off; - - if (whence == SEEK_END || off <= 0) - return Fseek(off, (int) fd, whence); - current_off = Fseek(0, (int) fd, SEEK_CUR); /* find out where we are */ - if (whence == SEEK_SET) - expected_off = off; - else - expected_off = off + current_off; - new_off = Fseek(off, (int) fd, whence); - if (new_off == expected_off) - return new_off; - /* otherwise extend file -- zero filling the hole */ - if (new_off < 0) /* error? */ - new_off = Fseek(0, (int) fd, SEEK_END); /* go to eof */ - _TIFFmemset(buf, 0, sizeof(buf)); - while (expected_off > new_off) { - off = expected_off - new_off; - if (off > sizeof(buf)) - off = sizeof(buf); - if ((current_off = Fwrite((int) fd, off, buf)) != off) - return (current_off > 0) ? - new_off + current_off : new_off; - new_off += off; - } - return new_off; -} - -static int -_tiffCloseProc(thandle_t fd) -{ - long r; - - r = Fclose((int) fd); - if (r < 0) { - errno = (int)-r; - r = -1; - } - return (int)r; -} - -static toff_t -_tiffSizeProc(thandle_t fd) -{ - long pos, eof; - - pos = Fseek(0, (int) fd, SEEK_CUR); - eof = Fseek(0, (int) fd, SEEK_END); - Fseek(pos, (int) fd, SEEK_SET); - return eof; -} - -static int -_tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) -{ - return (0); -} - -static void -_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size) -{ -} - -/* -* Open a TIFF file descriptor for read/writing. -*/ -TIFF* -TIFFFdOpen(int fd, const char* name, const char* mode) -{ - TIFF* tif; - - tif = TIFFClientOpen(name, mode, - (thandle_t) fd, - _tiffReadProc, _tiffWriteProc, _tiffSeekProc, _tiffCloseProc, - _tiffSizeProc, _tiffMapProc, _tiffUnmapProc); - if (tif) - tif->tif_fd = fd; - return (tif); -} - -/* -* Open a TIFF file for read/writing. -*/ -TIFF* -TIFFOpen(const char* name, const char* mode) -{ - static const char module[] = "TIFFOpen"; - int m; - long fd; - - m = _TIFFgetMode(mode, module); - if (m == -1) - return ((TIFF*)0); - if (m & O_TRUNC) { - fd = Fcreate(name, 0); - } else { - fd = Fopen(name, m & O_ACCMODE); - if (fd == AEFILNF && m & O_CREAT) - fd = Fcreate(name, 0); - } - if (fd < 0) - errno = (int)fd; - if (fd < 0) { - TIFFErrorExt(0, module, "%s: Cannot open", name); - return ((TIFF*)0); - } - return (TIFFFdOpen(fd, name, mode)); -} - -#include <stdlib.h> - -tdata_t -_TIFFmalloc(tsize_t s) -{ - return (malloc((size_t) s)); -} - -void -_TIFFfree(tdata_t p) -{ - free(p); -} - -tdata_t -_TIFFrealloc(tdata_t p, tsize_t s) -{ - return (realloc(p, (size_t) s)); -} - -void -_TIFFmemset(tdata_t p, int v, size_t c) -{ - memset(p, v, (size_t) c); -} - -void -_TIFFmemcpy(tdata_t d, const tdata_t s, size_t c) -{ - memcpy(d, s, (size_t) c); -} - -int -_TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c) -{ - return (memcmp(p1, p2, (size_t) c)); -} - -static void -atariWarningHandler(const char* module, const char* fmt, va_list ap) -{ - if (module != NULL) - fprintf(stderr, "%s: ", module); - fprintf(stderr, "Warning, "); - vfprintf(stderr, fmt, ap); - fprintf(stderr, ".\n"); -} -TIFFErrorHandler _TIFFwarningHandler = atariWarningHandler; - -static void -atariErrorHandler(const char* module, const char* fmt, va_list ap) -{ - if (module != NULL) - fprintf(stderr, "%s: ", module); - vfprintf(stderr, fmt, ap); - fprintf(stderr, ".\n"); -} -TIFFErrorHandler _TIFFerrorHandler = atariErrorHandler; diff --git a/src/3rdparty/libtiff/libtiff/tif_aux.c b/src/3rdparty/libtiff/libtiff/tif_aux.c index 43d591b..927150a 100644 --- a/src/3rdparty/libtiff/libtiff/tif_aux.c +++ b/src/3rdparty/libtiff/libtiff/tif_aux.c @@ -1,4 +1,4 @@ -/* $Id: tif_aux.c,v 1.20 2006/06/08 14:24:13 dron Exp $ */ +/* $Id: tif_aux.c,v 1.26 2010-07-01 15:33:28 dron Exp $ */ /* * Copyright (c) 1991-1997 Sam Leffler @@ -33,12 +33,38 @@ #include "tif_predict.h" #include <math.h> -tdata_t -_TIFFCheckRealloc(TIFF* tif, tdata_t buffer, - size_t nmemb, size_t elem_size, const char* what) +uint32 +_TIFFMultiply32(TIFF* tif, uint32 first, uint32 second, const char* where) { - tdata_t cp = NULL; - tsize_t bytes = nmemb * elem_size; + uint32 bytes = first * second; + + if (second && bytes / second != first) { + TIFFErrorExt(tif->tif_clientdata, where, "Integer overflow in %s", where); + bytes = 0; + } + + return bytes; +} + +uint64 +_TIFFMultiply64(TIFF* tif, uint64 first, uint64 second, const char* where) +{ + uint64 bytes = first * second; + + if (second && bytes / second != first) { + TIFFErrorExt(tif->tif_clientdata, where, "Integer overflow in %s", where); + bytes = 0; + } + + return bytes; +} + +void* +_TIFFCheckRealloc(TIFF* tif, void* buffer, + tmsize_t nmemb, tmsize_t elem_size, const char* what) +{ + void* cp = NULL; + tmsize_t bytes = nmemb * elem_size; /* * XXX: Check for integer overflow. @@ -46,30 +72,33 @@ _TIFFCheckRealloc(TIFF* tif, tdata_t buffer, if (nmemb && elem_size && bytes / elem_size == nmemb) cp = _TIFFrealloc(buffer, bytes); - if (cp == NULL) + if (cp == NULL) { TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "No space %s", what); + "Failed to allocate memory for %s " + "(%ld elements of %ld bytes each)", + what,(long) nmemb, (long) elem_size); + } return cp; } -tdata_t -_TIFFCheckMalloc(TIFF* tif, size_t nmemb, size_t elem_size, const char* what) +void* +_TIFFCheckMalloc(TIFF* tif, tmsize_t nmemb, tmsize_t elem_size, const char* what) { - return _TIFFCheckRealloc(tif, NULL, nmemb, elem_size, what); + return _TIFFCheckRealloc(tif, NULL, nmemb, elem_size, what); } static int TIFFDefaultTransferFunction(TIFFDirectory* td) { uint16 **tf = td->td_transferfunction; - tsize_t i, n, nbytes; + tmsize_t i, n, nbytes; tf[0] = tf[1] = tf[2] = 0; - if (td->td_bitspersample >= sizeof(tsize_t) * 8 - 2) + if (td->td_bitspersample >= sizeof(tmsize_t) * 8 - 2) return 0; - n = 1<<td->td_bitspersample; + n = ((tmsize_t)1)<<td->td_bitspersample; nbytes = n * sizeof (uint16); if (!(tf[0] = (uint16 *)_TIFFmalloc(nbytes))) return 0; @@ -100,6 +129,35 @@ bad: return 0; } +static int +TIFFDefaultRefBlackWhite(TIFFDirectory* td) +{ + int i; + + if (!(td->td_refblackwhite = (float *)_TIFFmalloc(6*sizeof (float)))) + return 0; + if (td->td_photometric == PHOTOMETRIC_YCBCR) { + /* + * YCbCr (Class Y) images must have the ReferenceBlackWhite + * tag set. Fix the broken images, which lacks that tag. + */ + td->td_refblackwhite[0] = 0.0F; + td->td_refblackwhite[1] = td->td_refblackwhite[3] = + td->td_refblackwhite[5] = 255.0F; + td->td_refblackwhite[2] = td->td_refblackwhite[4] = 128.0F; + } else { + /* + * Assume RGB (Class R) + */ + for (i = 0; i < 3; i++) { + td->td_refblackwhite[2*i+0] = 0; + td->td_refblackwhite[2*i+1] = + (float)((1L<<td->td_bitspersample)-1L); + } + } + return 1; +} + /* * Like TIFFGetField, but return any default * value if the tag is not present in the directory. @@ -109,7 +167,7 @@ bad: * place in the library -- in TIFFDefaultDirectory. */ int -TIFFVGetFieldDefaulted(TIFF* tif, ttag_t tag, va_list ap) +TIFFVGetFieldDefaulted(TIFF* tif, uint32 tag, va_list ap) { TIFFDirectory *td = &tif->tif_dir; @@ -225,33 +283,10 @@ TIFFVGetFieldDefaulted(TIFF* tif, ttag_t tag, va_list ap) } return (1); case TIFFTAG_REFERENCEBLACKWHITE: - { - int i; - static float ycbcr_refblackwhite[] = - { 0.0F, 255.0F, 128.0F, 255.0F, 128.0F, 255.0F }; - static float rgb_refblackwhite[6]; - - for (i = 0; i < 3; i++) { - rgb_refblackwhite[2 * i + 0] = 0.0F; - rgb_refblackwhite[2 * i + 1] = - (float)((1L<<td->td_bitspersample)-1L); - } - - if (td->td_photometric == PHOTOMETRIC_YCBCR) { - /* - * YCbCr (Class Y) images must have the - * ReferenceBlackWhite tag set. Fix the - * broken images, which lacks that tag. - */ - *va_arg(ap, float **) = ycbcr_refblackwhite; - } else { - /* - * Assume RGB (Class R) - */ - *va_arg(ap, float **) = rgb_refblackwhite; - } - return 1; - } + if (!td->td_refblackwhite && !TIFFDefaultRefBlackWhite(td)) + return (0); + *va_arg(ap, float **) = td->td_refblackwhite; + return (1); } return 0; } @@ -261,7 +296,7 @@ TIFFVGetFieldDefaulted(TIFF* tif, ttag_t tag, va_list ap) * value if the tag is not present in the directory. */ int -TIFFGetFieldDefaulted(TIFF* tif, ttag_t tag, ...) +TIFFGetFieldDefaulted(TIFF* tif, uint32 tag, ...) { int ok; va_list ap; @@ -272,4 +307,52 @@ TIFFGetFieldDefaulted(TIFF* tif, ttag_t tag, ...) return (ok); } +struct _Int64Parts { + int32 low, high; +}; + +typedef union { + struct _Int64Parts part; + int64 value; +} _Int64; + +float +_TIFFUInt64ToFloat(uint64 ui64) +{ + _Int64 i; + + i.value = ui64; + if (i.part.high >= 0) { + return (float)i.value; + } else { + long double df; + df = (long double)i.value; + df += 18446744073709551616.0; /* adding 2**64 */ + return (float)df; + } +} + +double +_TIFFUInt64ToDouble(uint64 ui64) +{ + _Int64 i; + + i.value = ui64; + if (i.part.high >= 0) { + return (double)i.value; + } else { + long double df; + df = (long double)i.value; + df += 18446744073709551616.0; /* adding 2**64 */ + return (double)df; + } +} + /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_close.c b/src/3rdparty/libtiff/libtiff/tif_close.c index 3623277..13d2bab 100644 --- a/src/3rdparty/libtiff/libtiff/tif_close.c +++ b/src/3rdparty/libtiff/libtiff/tif_close.c @@ -1,4 +1,4 @@ -/* $Id: tif_close.c,v 1.10 2006/03/25 03:09:24 joris Exp $ */ +/* $Id: tif_close.c,v 1.19 2010-03-10 18:56:48 bfriesen Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler @@ -28,6 +28,7 @@ * TIFF Library. */ #include "tiffiop.h" +#include <string.h> /************************************************************************/ /* TIFFCleanup() */ @@ -45,18 +46,20 @@ void TIFFCleanup(TIFF* tif) { + /* + * Flush buffered data and directory (if dirty). + */ if (tif->tif_mode != O_RDONLY) - /* - * Flush buffered data and directory (if dirty). - */ - TIFFFlush(tif); + TIFFFlush(tif); (*tif->tif_cleanup)(tif); TIFFFreeDirectory(tif); if (tif->tif_dirlist) _TIFFfree(tif->tif_dirlist); - /* Clean up client info links */ + /* + * Clean up client info links. + */ while( tif->tif_clientinfo ) { TIFFClientInfoLink *link = tif->tif_clientinfo; @@ -69,27 +72,36 @@ TIFFCleanup(TIFF* tif) if (tif->tif_rawdata && (tif->tif_flags&TIFF_MYBUFFER)) _TIFFfree(tif->tif_rawdata); if (isMapped(tif)) - TIFFUnmapFileContents(tif, tif->tif_base, tif->tif_size); - - /* Clean up custom fields */ - if (tif->tif_nfields > 0) - { - size_t i; - - for (i = 0; i < tif->tif_nfields; i++) - { - TIFFFieldInfo *fld = tif->tif_fieldinfo[i]; - if (fld->field_bit == FIELD_CUSTOM && - strncmp("Tag ", fld->field_name, 4) == 0) - { - _TIFFfree(fld->field_name); - _TIFFfree(fld); + TIFFUnmapFileContents(tif, tif->tif_base, (toff_t)tif->tif_size); + + /* + * Clean up custom fields. + */ + if (tif->tif_fields && tif->tif_nfields > 0) { + uint32 i; + + for (i = 0; i < tif->tif_nfields; i++) { + TIFFField *fld = tif->tif_fields[i]; + if (fld->field_bit == FIELD_CUSTOM && + strncmp("Tag ", fld->field_name, 4) == 0) { + _TIFFfree(fld->field_name); + _TIFFfree(fld); + } } - } - - _TIFFfree(tif->tif_fieldinfo); + + _TIFFfree(tif->tif_fields); } + if (tif->tif_nfieldscompat > 0) { + uint32 i; + + for (i = 0; i < tif->tif_nfieldscompat; i++) { + if (tif->tif_fieldscompat[i].allocated_size) + _TIFFfree(tif->tif_fieldscompat[i].fields); + } + _TIFFfree(tif->tif_fieldscompat); + } + _TIFFfree(tif); } @@ -117,3 +129,12 @@ TIFFClose(TIFF* tif) (void) (*closeproc)(fd); } +/* vim: set ts=8 sts=8 sw=8 noet: */ + +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_codec.c b/src/3rdparty/libtiff/libtiff/tif_codec.c index 02fb839..e201667 100644 --- a/src/3rdparty/libtiff/libtiff/tif_codec.c +++ b/src/3rdparty/libtiff/libtiff/tif_codec.c @@ -1,4 +1,4 @@ -/* $Id: tif_codec.c,v 1.10.2.1 2008-12-18 19:50:41 fwarmerdam Exp $ */ +/* $Id: tif_codec.c,v 1.15 2010-12-14 12:53:00 dron Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler @@ -31,43 +31,46 @@ */ #include "tiffiop.h" -static int NotConfigured(TIFF*, int); +static int NotConfigured(TIFF*, int); -#ifndef LZW_SUPPORT -#define TIFFInitLZW NotConfigured +#ifndef LZW_SUPPORT +#define TIFFInitLZW NotConfigured #endif -#ifndef PACKBITS_SUPPORT -#define TIFFInitPackBits NotConfigured +#ifndef PACKBITS_SUPPORT +#define TIFFInitPackBits NotConfigured #endif -#ifndef THUNDER_SUPPORT -#define TIFFInitThunderScan NotConfigured +#ifndef THUNDER_SUPPORT +#define TIFFInitThunderScan NotConfigured #endif -#ifndef NEXT_SUPPORT -#define TIFFInitNeXT NotConfigured +#ifndef NEXT_SUPPORT +#define TIFFInitNeXT NotConfigured #endif -#ifndef JPEG_SUPPORT -#define TIFFInitJPEG NotConfigured +#ifndef JPEG_SUPPORT +#define TIFFInitJPEG NotConfigured #endif -#ifndef OJPEG_SUPPORT -#define TIFFInitOJPEG NotConfigured +#ifndef OJPEG_SUPPORT +#define TIFFInitOJPEG NotConfigured #endif -#ifndef CCITT_SUPPORT -#define TIFFInitCCITTRLE NotConfigured -#define TIFFInitCCITTRLEW NotConfigured -#define TIFFInitCCITTFax3 NotConfigured -#define TIFFInitCCITTFax4 NotConfigured +#ifndef CCITT_SUPPORT +#define TIFFInitCCITTRLE NotConfigured +#define TIFFInitCCITTRLEW NotConfigured +#define TIFFInitCCITTFax3 NotConfigured +#define TIFFInitCCITTFax4 NotConfigured #endif #ifndef JBIG_SUPPORT -#define TIFFInitJBIG NotConfigured +#define TIFFInitJBIG NotConfigured #endif -#ifndef ZIP_SUPPORT -#define TIFFInitZIP NotConfigured +#ifndef ZIP_SUPPORT +#define TIFFInitZIP NotConfigured #endif -#ifndef PIXARLOG_SUPPORT -#define TIFFInitPixarLog NotConfigured +#ifndef PIXARLOG_SUPPORT +#define TIFFInitPixarLog NotConfigured #endif #ifndef LOGLUV_SUPPORT -#define TIFFInitSGILog NotConfigured +#define TIFFInitSGILog NotConfigured +#endif +#ifndef LZMA_SUPPORT +#define TIFFInitLZMA NotConfigured #endif /* @@ -95,6 +98,7 @@ TIFFCodec _TIFFBuiltinCODECS[] = { { "PixarLog", COMPRESSION_PIXARLOG, TIFFInitPixarLog }, { "SGILog", COMPRESSION_SGILOG, TIFFInitSGILog }, { "SGILog24", COMPRESSION_SGILOG24, TIFFInitSGILog }, + { "LZMA", COMPRESSION_LZMA, TIFFInitLZMA }, { NULL, 0, NULL } }; @@ -114,13 +118,14 @@ _notConfigured(TIFF* tif) static int NotConfigured(TIFF* tif, int scheme) { - (void) scheme; - - tif->tif_decodestatus = FALSE; - tif->tif_setupdecode = _notConfigured; - tif->tif_encodestatus = FALSE; - tif->tif_setupencode = _notConfigured; - return (1); + (void) scheme; + + tif->tif_fixuptags = _notConfigured; + tif->tif_decodestatus = FALSE; + tif->tif_setupdecode = _notConfigured; + tif->tif_encodestatus = FALSE; + tif->tif_setupencode = _notConfigured; + return (1); } /************************************************************************/ @@ -129,7 +134,7 @@ NotConfigured(TIFF* tif, int scheme) /** * Check whether we have working codec for the specific coding scheme. - * + * * @return returns 1 if the codec is configured and working. Otherwise * 0 will be returned. */ @@ -140,14 +145,21 @@ TIFFIsCODECConfigured(uint16 scheme) const TIFFCodec* codec = TIFFFindCODEC(scheme); if(codec == NULL) { - return 0; - } - if(codec->init == NULL) { - return 0; - } + return 0; + } + if(codec->init == NULL) { + return 0; + } if(codec->init != NotConfigured){ - return 1; - } + return 1; + } return 0; } +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_color.c b/src/3rdparty/libtiff/libtiff/tif_color.c index 0f484aa..be4850c 100644 --- a/src/3rdparty/libtiff/libtiff/tif_color.c +++ b/src/3rdparty/libtiff/libtiff/tif_color.c @@ -1,4 +1,4 @@ -/* $Id: tif_color.c,v 1.12 2006/02/09 15:42:20 dron Exp $ */ +/* $Id: tif_color.c,v 1.19 2010-12-14 02:22:42 faxguy Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler @@ -123,7 +123,7 @@ TIFFXYZToRGB(TIFFCIELabToRGB *cielab, float X, float Y, float Z, */ int TIFFCIELabToRGBInit(TIFFCIELabToRGB* cielab, - TIFFDisplay *display, float *refWhite) + const TIFFDisplay *display, float *refWhite) { int i; double gamma; @@ -183,13 +183,18 @@ void TIFFYCbCrtoRGB(TIFFYCbCrToRGB *ycbcr, uint32 Y, int32 Cb, int32 Cr, uint32 *r, uint32 *g, uint32 *b) { + int32 i; + /* XXX: Only 8-bit YCbCr input supported for now */ Y = HICLAMP(Y, 255), Cb = CLAMP(Cb, 0, 255), Cr = CLAMP(Cr, 0, 255); - *r = ycbcr->clamptab[ycbcr->Y_tab[Y] + ycbcr->Cr_r_tab[Cr]]; - *g = ycbcr->clamptab[ycbcr->Y_tab[Y] - + (int)((ycbcr->Cb_g_tab[Cb] + ycbcr->Cr_g_tab[Cr]) >> SHIFT)]; - *b = ycbcr->clamptab[ycbcr->Y_tab[Y] + ycbcr->Cb_b_tab[Cb]]; + i = ycbcr->Y_tab[Y] + ycbcr->Cr_r_tab[Cr]; + *r = CLAMP(i, 0, 255); + i = ycbcr->Y_tab[Y] + + (int)((ycbcr->Cb_g_tab[Cb] + ycbcr->Cr_g_tab[Cr]) >> SHIFT); + *g = CLAMP(i, 0, 255); + i = ycbcr->Y_tab[Y] + ycbcr->Cb_b_tab[Cb]; + *b = CLAMP(i, 0, 255); } /* @@ -219,7 +224,7 @@ TIFFYCbCrToRGBInit(TIFFYCbCrToRGB* ycbcr, float *luma, float *refBlackWhite) #define LumaBlue luma[2] clamptab = (TIFFRGBValue*)( - (tidata_t) ycbcr+TIFFroundup(sizeof (TIFFYCbCrToRGB), sizeof (long))); + (uint8*) ycbcr+TIFFroundup_32(sizeof (TIFFYCbCrToRGB), sizeof (long))); _TIFFmemset(clamptab, 0, 256); /* v < 0 => 0 */ ycbcr->clamptab = (clamptab += 256); for (i = 0; i < 256; i++) @@ -273,3 +278,10 @@ TIFFYCbCrToRGBInit(TIFFYCbCrToRGB* ycbcr, float *luma, float *refBlackWhite) #undef FIX /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_compress.c b/src/3rdparty/libtiff/libtiff/tif_compress.c index 6c3f322..20e72fd 100644 --- a/src/3rdparty/libtiff/libtiff/tif_compress.c +++ b/src/3rdparty/libtiff/libtiff/tif_compress.c @@ -1,4 +1,4 @@ -/* $Id: tif_compress.c,v 1.13 2007/02/24 15:03:50 dron Exp $ */ +/* $Id: tif_compress.c,v 1.22 2010-03-10 18:56:48 bfriesen Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler @@ -36,11 +36,11 @@ TIFFNoEncode(TIFF* tif, const char* method) { const TIFFCodec* c = TIFFFindCODEC(tif->tif_dir.td_compression); - if (c) { + if (c) { TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "%s %s encoding is not implemented", c->name, method); - } else { + } else { TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Compression scheme %u %s encoding is not implemented", tif->tif_dir.td_compression, method); @@ -49,21 +49,21 @@ TIFFNoEncode(TIFF* tif, const char* method) } int -_TIFFNoRowEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s) +_TIFFNoRowEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s) { (void) pp; (void) cc; (void) s; return (TIFFNoEncode(tif, "scanline")); } int -_TIFFNoStripEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s) +_TIFFNoStripEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s) { (void) pp; (void) cc; (void) s; return (TIFFNoEncode(tif, "strip")); } int -_TIFFNoTileEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s) +_TIFFNoTileEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s) { (void) pp; (void) cc; (void) s; return (TIFFNoEncode(tif, "tile")); @@ -86,21 +86,28 @@ TIFFNoDecode(TIFF* tif, const char* method) } int -_TIFFNoRowDecode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s) +_TIFFNoFixupTags(TIFF* tif) +{ + (void) tif; + return (1); +} + +int +_TIFFNoRowDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s) { (void) pp; (void) cc; (void) s; return (TIFFNoDecode(tif, "scanline")); } int -_TIFFNoStripDecode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s) +_TIFFNoStripDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s) { (void) pp; (void) cc; (void) s; return (TIFFNoDecode(tif, "strip")); } int -_TIFFNoTileDecode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s) +_TIFFNoTileDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s) { (void) pp; (void) cc; (void) s; return (TIFFNoDecode(tif, "tile")); @@ -116,7 +123,7 @@ _TIFFNoSeek(TIFF* tif, uint32 off) } int -_TIFFNoPreCode(TIFF* tif, tsample_t s) +_TIFFNoPreCode(TIFF* tif, uint16 s) { (void) tif; (void) s; return (1); @@ -128,19 +135,20 @@ static void _TIFFvoid(TIFF* tif) { (void) tif; } void _TIFFSetDefaultCompressionState(TIFF* tif) { + tif->tif_fixuptags = _TIFFNoFixupTags; tif->tif_decodestatus = TRUE; tif->tif_setupdecode = _TIFFtrue; tif->tif_predecode = _TIFFNoPreCode; - tif->tif_decoderow = _TIFFNoRowDecode; + tif->tif_decoderow = _TIFFNoRowDecode; tif->tif_decodestrip = _TIFFNoStripDecode; - tif->tif_decodetile = _TIFFNoTileDecode; + tif->tif_decodetile = _TIFFNoTileDecode; tif->tif_encodestatus = TRUE; tif->tif_setupencode = _TIFFtrue; tif->tif_preencode = _TIFFNoPreCode; tif->tif_postencode = _TIFFtrue; tif->tif_encoderow = _TIFFNoRowEncode; - tif->tif_encodestrip = _TIFFNoStripEncode; - tif->tif_encodetile = _TIFFNoTileEncode; + tif->tif_encodestrip = _TIFFNoStripEncode; + tif->tif_encodetile = _TIFFNoTileEncode; tif->tif_close = _TIFFvoid; tif->tif_seek = _TIFFNoSeek; tif->tif_cleanup = _TIFFvoid; @@ -170,10 +178,10 @@ TIFFSetCompressionScheme(TIFF* tif, int scheme) * by this library. */ typedef struct _codec { - struct _codec* next; - TIFFCodec* info; + struct _codec* next; + TIFFCodec* info; } codec_t; -static codec_t* registeredCODECS = NULL; +static codec_t* registeredCODECS = NULL; const TIFFCodec* TIFFFindCODEC(uint16 scheme) @@ -194,12 +202,12 @@ TIFFCodec* TIFFRegisterCODEC(uint16 scheme, const char* name, TIFFInitMethod init) { codec_t* cd = (codec_t*) - _TIFFmalloc(sizeof (codec_t) + sizeof (TIFFCodec) + strlen(name)+1); + _TIFFmalloc((tmsize_t)(sizeof (codec_t) + sizeof (TIFFCodec) + strlen(name)+1)); if (cd != NULL) { - cd->info = (TIFFCodec*) ((tidata_t) cd + sizeof (codec_t)); + cd->info = (TIFFCodec*) ((uint8*) cd + sizeof (codec_t)); cd->info->name = (char*) - ((tidata_t) cd->info + sizeof (TIFFCodec)); + ((uint8*) cd->info + sizeof (TIFFCodec)); strcpy(cd->info->name, name); cd->info->scheme = scheme; cd->info->init = init; @@ -244,13 +252,14 @@ TIFFUnRegisterCODEC(TIFFCodec* c) TIFFCodec* TIFFGetConfiguredCODECs() { - int i = 1; - codec_t *cd; - const TIFFCodec *c; - TIFFCodec *codecs = NULL, *new_codecs; + int i = 1; + codec_t *cd; + const TIFFCodec* c; + TIFFCodec* codecs = NULL; + TIFFCodec* new_codecs; - for (cd = registeredCODECS; cd; cd = cd->next) { - new_codecs = (TIFFCodec *) + for (cd = registeredCODECS; cd; cd = cd->next) { + new_codecs = (TIFFCodec *) _TIFFrealloc(codecs, i * sizeof(TIFFCodec)); if (!new_codecs) { _TIFFfree (codecs); @@ -260,16 +269,16 @@ TIFFGetConfiguredCODECs() _TIFFmemcpy(codecs + i - 1, cd, sizeof(TIFFCodec)); i++; } - for (c = _TIFFBuiltinCODECS; c->name; c++) { - if (TIFFIsCODECConfigured(c->scheme)) { - new_codecs = (TIFFCodec *) + for (c = _TIFFBuiltinCODECS; c->name; c++) { + if (TIFFIsCODECConfigured(c->scheme)) { + new_codecs = (TIFFCodec *) _TIFFrealloc(codecs, i * sizeof(TIFFCodec)); if (!new_codecs) { _TIFFfree (codecs); return NULL; } codecs = new_codecs; - _TIFFmemcpy(codecs + i - 1, (const tdata_t)c, sizeof(TIFFCodec)); + _TIFFmemcpy(codecs + i - 1, (const void*)c, sizeof(TIFFCodec)); i++; } } @@ -282,7 +291,14 @@ TIFFGetConfiguredCODECs() codecs = new_codecs; _TIFFmemset(codecs + i - 1, 0, sizeof(TIFFCodec)); - return codecs; + return codecs; } /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_config.h b/src/3rdparty/libtiff/libtiff/tif_config.h index 97faf38..64ab64b 100644 --- a/src/3rdparty/libtiff/libtiff/tif_config.h +++ b/src/3rdparty/libtiff/libtiff/tif_config.h @@ -2,6 +2,10 @@ Configuration defines for Qt. */ +#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS) +#define _CRT_SECURE_NO_WARNINGS +#endif + #include <qglobal.h> #if defined(Q_OS_WINCE) # include <qfunctions_wince.h> @@ -11,11 +15,14 @@ /* #undef AC_APPLE_UNIVERSAL_BUILD */ /* Support CCITT Group 3 & 4 algorithms */ -#define CCITT_SUPPORT 1 +/* #undef CCITT_SUPPORT */ /* Pick up YCbCr subsampling info from the JPEG data stream to support files lacking the tag (default enabled). */ -#define CHECK_JPEG_YCBCR_SUBSAMPLING 1 +/* #undef CHECK_JPEG_YCBCR_SUBSAMPLING */ + +/* enable partial strip reading for large strips (experimental) */ +/* #undef CHUNKY_STRIP_READ_SUPPORT */ /* Support C++ stream API (requires C++ compiler) */ /* #undef CXX_SUPPORT */ @@ -23,10 +30,10 @@ /* Treat extra sample as alpha (default enabled). The RGBA interface will treat a fourth sample with no EXTRASAMPLE_ value as being ASSOCALPHA. Many packages produce RGBA files but don't mark the alpha properly. */ -#define DEFAULT_EXTRASAMPLE_AS_ALPHA 1 +/* #undef DEFAULT_EXTRASAMPLE_AS_ALPHA */ -/* Use the Apple OpenGL framework. */ -/* #undef HAVE_APPLE_OPENGL_FRAMEWORK */ +/* enable deferred strip/tile offset/size loading (experimental) */ +/* #undef DEFER_STRILE_LOAD */ /* Define to 1 if you have the <assert.h> header file. */ #define HAVE_ASSERT_H 1 @@ -45,9 +52,21 @@ /* Define to 1 if you have the `getopt' function. */ /* #undef HAVE_GETOPT */ +/* Define to 1 if you have the <GLUT/glut.h> header file. */ +/* #undef HAVE_GLUT_GLUT_H */ + +/* Define to 1 if you have the <GL/glut.h> header file. */ +/* #undef HAVE_GL_GLUT_H */ + +/* Define to 1 if you have the <GL/glu.h> header file. */ +/* #undef HAVE_GL_GLU_H */ + +/* Define to 1 if you have the <GL/gl.h> header file. */ +/* #undef HAVE_GL_GL_H */ + /* Define as 0 or 1 according to the floating point format suported by the machine */ -#define HAVE_IEEEFP 1 +/* #undef HAVE_IEEEFP */ /* Define to 1 if the system has the type `int16'. */ #ifdef Q_OS_AIX @@ -103,6 +122,12 @@ /* Define to 1 if you have the `mmap' function. */ /* #undef HAVE_MMAP */ +/* Define to 1 if you have the <OpenGL/glu.h> header file. */ +/* #undef HAVE_OPENGL_GLU_H */ + +/* Define to 1 if you have the <OpenGL/gl.h> header file. */ +/* #undef HAVE_OPENGL_GL_H */ + /* Define to 1 if you have the `pow' function. */ /* #undef HAVE_POW */ @@ -110,7 +135,7 @@ /* #undef HAVE_PTHREAD */ /* Define to 1 if you have the <search.h> header file. */ -#if !defined(Q_OS_WINCE) && !defined(Q_OS_SYMBIAN) && !defined(Q_OS_VXWORKS) +#if !defined(Q_OS_WINCE) && !defined(Q_OS_VXWORKS) && !defined(Q_OS_ANDROID) #define HAVE_SEARCH_H 1 #endif @@ -150,6 +175,9 @@ /* Define to 1 if you have the `strtoul' function. */ /* #undef HAVE_STRTOUL */ +/* Define to 1 if you have the `strtoull' function. */ +/* #undef HAVE_STRTOULL */ + /* Define to 1 if you have the <sys/stat.h> header file. */ /* #undef HAVE_SYS_STAT_H */ @@ -164,41 +192,49 @@ #define HAVE_UNISTD_H 1 #endif +/* Use nonstandard varargs form for the GLU tesselator callback */ +/* #undef HAVE_VARARGS_GLU_TESSCB */ + /* Define to 1 if you have the <windows.h> header file. */ /* #undef HAVE_WINDOWS_H */ /* Native cpu byte order: 1 if big-endian (Motorola) or 0 if little-endian (Intel) */ -#if (Q_BYTE_ORDER == Q_BIG_ENDIAN) -#define HOST_BIGENDIAN 1 -#else -#define HOST_BIGENDIAN 0 -#endif +/* #undef HOST_BIGENDIAN */ /* Set the native cpu bit order (FILLORDER_LSB2MSB or FILLORDER_MSB2LSB) */ -#define HOST_FILLORDER FILLORDER_LSB2MSB +/* #undef HOST_FILLORDER FILLORDER_LSB2MSB */ /* Support ISO JBIG compression (requires JBIG-KIT library) */ /* #undef JBIG_SUPPORT */ +/* 8/12 bit libjpeg dual mode enabled */ +/* #undef JPEG_DUAL_MODE_8_12 */ + /* Support JPEG compression (requires IJG JPEG library) */ /* #undef JPEG_SUPPORT */ +/* 12bit libjpeg primary include file with path */ +/* #undef LIBJPEG_12_PATH */ + /* Support LogLuv high dynamic range encoding */ -#define LOGLUV_SUPPORT 1 +/* #undef LOGLUV_SUPPORT */ /* Define to the sub-directory in which libtool stores uninstalled libraries. */ /* #undef LT_OBJDIR */ +/* Support LZMA2 compression */ +/* #undef LZMA_SUPPORT */ + /* Support LZW algorithm */ -#define LZW_SUPPORT 1 +/* #undef LZW_SUPPORT */ /* Support Microsoft Document Imaging format */ -#define MDI_SUPPORT 1 +/* #undef MDI_SUPPORT */ /* Support NeXT 2-bit RLE algorithm */ -#define NEXT_SUPPORT 1 +/* #undef NEXT_SUPPORT */ /* Define to 1 if your C compiler doesn't accept -c and -o together. */ /* #undef NO_MINUS_C_MINUS_O */ @@ -225,27 +261,20 @@ /* #undef PACKAGE_URL */ /* Define to the version of this package. */ -#define PACKAGE_VERSION "3.9.2" +#define PACKAGE_VERSION "4.0.3" /* Support Macintosh PackBits algorithm */ -#define PACKBITS_SUPPORT 1 +/* #undef PACKBITS_SUPPORT */ /* Support Pixar log-format algorithm (requires Zlib) */ -#define PIXARLOG_SUPPORT 1 +/* #undef PIXARLOG_SUPPORT */ /* Define to necessary symbol if this constant uses a non-standard name on your system. */ /* #undef PTHREAD_CREATE_JOINABLE */ -/* The size of `int', as computed by sizeof. */ -#define SIZEOF_INT 4 - -/* The size of `long', as computed by sizeof. */ -#if (QT_POINTER_SIZE == 8) && !defined(Q_OS_WIN64) -#define SIZEOF_LONG 8 -#else -#define SIZEOF_LONG 4 -#endif +/* The size of `signed int', as computed by sizeof. */ +/* #undef SIZEOF_SIGNED_INT */ /* The size of `signed long', as computed by sizeof. */ /* #undef SIZEOF_SIGNED_LONG */ @@ -253,39 +282,91 @@ /* The size of `signed long long', as computed by sizeof. */ /* #undef SIZEOF_SIGNED_LONG_LONG */ +/* The size of `signed short', as computed by sizeof. */ +/* #undef SIZEOF_SIGNED_SHORT */ + +/* The size of `unsigned char *', as computed by sizeof. */ +/* #undef SIZEOF_UNSIGNED_CHAR_P */ + +/* The size of `unsigned int', as computed by sizeof. */ +/* #undef SIZEOF_UNSIGNED_INT */ + /* The size of `unsigned long', as computed by sizeof. */ /* #undef SIZEOF_UNSIGNED_LONG */ /* The size of `unsigned long long', as computed by sizeof. */ /* #undef SIZEOF_UNSIGNED_LONG_LONG */ +/* The size of `unsigned short', as computed by sizeof. */ +/* #undef SIZEOF_UNSIGNED_SHORT */ + /* Define to 1 if you have the ANSI C header files. */ /* #undef STDC_HEADERS */ /* Support strip chopping (whether or not to convert single-strip uncompressed images to mutiple strips of specified size to reduce memory usage) */ -#define STRIPCHOP_DEFAULT TIFF_STRIPCHOP +/* #undef STRIPCHOP_DEFAULT TIFF_STRIPCHOP */ /* Default size of the strip in bytes (when strip chopping enabled) */ /* #undef STRIP_SIZE_DEFAULT */ /* Enable SubIFD tag (330) support */ -#define SUBIFD_SUPPORT 1 +/* #undef SUBIFD_SUPPORT */ /* Support ThunderScan 4-bit RLE algorithm */ -#define THUNDER_SUPPORT 1 +/* #undef THUNDER_SUPPORT */ + +/* Signed 16-bit type */ +/* #undef TIFF_INT16_T qint16 */ + +/* Signed 32-bit type formatter */ +#define TIFF_INT32_FORMAT "%d" + +/* Signed 32-bit type */ +/* #undef TIFF_INT32_T qint32 */ /* Signed 64-bit type formatter */ -/* #undef TIFF_INT64_FORMAT */ +#define TIFF_INT64_FORMAT "%lld" /* Signed 64-bit type */ -#define TIFF_INT64_T qint64 +/* #undef TIFF_INT64_T qint64 */ + +/* Signed 8-bit type */ +/* #undef TIFF_INT8_T qint8 */ + +/* Pointer difference type formatter */ +#define TIFF_PTRDIFF_FORMAT "%ld" + +/* Pointer difference type */ +#define TIFF_PTRDIFF_T ptrdiff_t + +/* Signed size type formatter */ +#if QT_POINTER_SIZE == 4 +#define TIFF_SSIZE_FORMAT "%ld" +#else +#define TIFF_SSIZE_FORMAT "%lld" +#endif + +/* Signed size type */ +/* #undef TIFF_SSIZE_T qint64 */ + +/* Unsigned 16-bit type */ +/* #undef TIFF_UINT16_T quint16 */ + +/* Unsigned 32-bit type formatter */ +#define TIFF_UINT32_FORMAT "%u" + +/* Unsigned 32-bit type */ +/* #undef TIFF_UINT32_T quint32 */ /* Unsigned 64-bit type formatter */ -/* #undef TIFF_UINT64_FORMAT */ +#define TIFF_UINT64_FORMAT "%llu" /* Unsigned 64-bit type */ -#define TIFF_UINT64_T quint64 +/* #undef TIFF_UINT64_T quint64 */ + +/* Unsigned 8-bit type */ +/* #undef TIFF_UINT8_T quint8 */ /* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */ /* #undef TIME_WITH_SYS_TIME */ @@ -293,6 +374,11 @@ /* Define to 1 if your <sys/time.h> declares `struct tm'. */ /* #undef TM_IN_SYS_TIME */ +/* define to use win32 IO system */ +#ifdef Q_OS_WIN +#define USE_WIN32_FILEIO 1 +#endif + /* Version number of package */ /* #undef VERSION */ @@ -306,7 +392,14 @@ /* #undef X_DISPLAY_MISSING */ /* Support Deflate compression */ -#define ZIP_SUPPORT 1 +/* #undef ZIP_SUPPORT */ + +/* Enable large inode numbers on Mac OS X 10.5. */ +#if defined(Q_OS_MAC) +#ifndef _DARWIN_USE_64_BIT_INODE +# define _DARWIN_USE_64_BIT_INODE 1 +#endif +#endif /* Number of bits in a file offset, on hosts where this is settable. */ /* #undef _FILE_OFFSET_BITS */ @@ -317,6 +410,16 @@ /* Define to empty if `const' does not conform to ANSI C. */ /* #undef const */ +/* Define to `__inline__' or `__inline' if that's what the C compiler + calls it, or to nothing if 'inline' is not supported under any name. */ +#if defined(Q_CC_MSVC) +#ifndef __cplusplus +# ifndef inline +# define inline __inline +# endif +#endif +#endif + /* Define to `long int' if <sys/types.h> does not define. */ /* #undef off_t */ diff --git a/src/3rdparty/libtiff/libtiff/tif_config.h.in b/src/3rdparty/libtiff/libtiff/tif_config.h.in index 01e54de..b2cea35 100644 --- a/src/3rdparty/libtiff/libtiff/tif_config.h.in +++ b/src/3rdparty/libtiff/libtiff/tif_config.h.in @@ -10,6 +10,9 @@ lacking the tag (default enabled). */ #undef CHECK_JPEG_YCBCR_SUBSAMPLING +/* enable partial strip reading for large strips (experimental) */ +#undef CHUNKY_STRIP_READ_SUPPORT + /* Support C++ stream API (requires C++ compiler) */ #undef CXX_SUPPORT @@ -18,8 +21,8 @@ packages produce RGBA files but don't mark the alpha properly. */ #undef DEFAULT_EXTRASAMPLE_AS_ALPHA -/* Use the Apple OpenGL framework. */ -#undef HAVE_APPLE_OPENGL_FRAMEWORK +/* enable deferred strip/tile offset/size loading (experimental) */ +#undef DEFER_STRILE_LOAD /* Define to 1 if you have the <assert.h> header file. */ #undef HAVE_ASSERT_H @@ -36,6 +39,18 @@ /* Define to 1 if you have the `getopt' function. */ #undef HAVE_GETOPT +/* Define to 1 if you have the <GLUT/glut.h> header file. */ +#undef HAVE_GLUT_GLUT_H + +/* Define to 1 if you have the <GL/glut.h> header file. */ +#undef HAVE_GL_GLUT_H + +/* Define to 1 if you have the <GL/glu.h> header file. */ +#undef HAVE_GL_GLU_H + +/* Define to 1 if you have the <GL/gl.h> header file. */ +#undef HAVE_GL_GL_H + /* Define as 0 or 1 according to the floating point format suported by the machine */ #undef HAVE_IEEEFP @@ -64,9 +79,6 @@ /* Define to 1 if you have the `lfind' function. */ #undef HAVE_LFIND -/* Define to 1 if you have the `c' library (-lc). */ -#undef HAVE_LIBC - /* Define to 1 if you have the `m' library (-lm). */ #undef HAVE_LIBM @@ -88,6 +100,12 @@ /* Define to 1 if you have the `mmap' function. */ #undef HAVE_MMAP +/* Define to 1 if you have the <OpenGL/glu.h> header file. */ +#undef HAVE_OPENGL_GLU_H + +/* Define to 1 if you have the <OpenGL/gl.h> header file. */ +#undef HAVE_OPENGL_GL_H + /* Define to 1 if you have the `pow' function. */ #undef HAVE_POW @@ -133,6 +151,9 @@ /* Define to 1 if you have the `strtoul' function. */ #undef HAVE_STRTOUL +/* Define to 1 if you have the `strtoull' function. */ +#undef HAVE_STRTOULL + /* Define to 1 if you have the <sys/stat.h> header file. */ #undef HAVE_SYS_STAT_H @@ -145,6 +166,9 @@ /* Define to 1 if you have the <unistd.h> header file. */ #undef HAVE_UNISTD_H +/* Use nonstandard varargs form for the GLU tesselator callback */ +#undef HAVE_VARARGS_GLU_TESSCB + /* Define to 1 if you have the <windows.h> header file. */ #undef HAVE_WINDOWS_H @@ -158,9 +182,15 @@ /* Support ISO JBIG compression (requires JBIG-KIT library) */ #undef JBIG_SUPPORT +/* 8/12 bit libjpeg dual mode enabled */ +#undef JPEG_DUAL_MODE_8_12 + /* Support JPEG compression (requires IJG JPEG library) */ #undef JPEG_SUPPORT +/* 12bit libjpeg primary include file with path */ +#undef LIBJPEG_12_PATH + /* Support LogLuv high dynamic range encoding */ #undef LOGLUV_SUPPORT @@ -168,6 +198,9 @@ */ #undef LT_OBJDIR +/* Support LZMA2 compression */ +#undef LZMA_SUPPORT + /* Support LZW algorithm */ #undef LZW_SUPPORT @@ -214,11 +247,8 @@ your system. */ #undef PTHREAD_CREATE_JOINABLE -/* The size of `int', as computed by sizeof. */ -#undef SIZEOF_INT - -/* The size of `long', as computed by sizeof. */ -#undef SIZEOF_LONG +/* The size of `signed int', as computed by sizeof. */ +#undef SIZEOF_SIGNED_INT /* The size of `signed long', as computed by sizeof. */ #undef SIZEOF_SIGNED_LONG @@ -226,12 +256,24 @@ /* The size of `signed long long', as computed by sizeof. */ #undef SIZEOF_SIGNED_LONG_LONG +/* The size of `signed short', as computed by sizeof. */ +#undef SIZEOF_SIGNED_SHORT + +/* The size of `unsigned char *', as computed by sizeof. */ +#undef SIZEOF_UNSIGNED_CHAR_P + +/* The size of `unsigned int', as computed by sizeof. */ +#undef SIZEOF_UNSIGNED_INT + /* The size of `unsigned long', as computed by sizeof. */ #undef SIZEOF_UNSIGNED_LONG /* The size of `unsigned long long', as computed by sizeof. */ #undef SIZEOF_UNSIGNED_LONG_LONG +/* The size of `unsigned short', as computed by sizeof. */ +#undef SIZEOF_UNSIGNED_SHORT + /* Define to 1 if you have the ANSI C header files. */ #undef STDC_HEADERS @@ -248,24 +290,63 @@ /* Support ThunderScan 4-bit RLE algorithm */ #undef THUNDER_SUPPORT +/* Signed 16-bit type */ +#undef TIFF_INT16_T + +/* Signed 32-bit type formatter */ +#undef TIFF_INT32_FORMAT + +/* Signed 32-bit type */ +#undef TIFF_INT32_T + /* Signed 64-bit type formatter */ #undef TIFF_INT64_FORMAT /* Signed 64-bit type */ #undef TIFF_INT64_T +/* Signed 8-bit type */ +#undef TIFF_INT8_T + +/* Pointer difference type formatter */ +#undef TIFF_PTRDIFF_FORMAT + +/* Pointer difference type */ +#undef TIFF_PTRDIFF_T + +/* Signed size type formatter */ +#undef TIFF_SSIZE_FORMAT + +/* Signed size type */ +#undef TIFF_SSIZE_T + +/* Unsigned 16-bit type */ +#undef TIFF_UINT16_T + +/* Unsigned 32-bit type formatter */ +#undef TIFF_UINT32_FORMAT + +/* Unsigned 32-bit type */ +#undef TIFF_UINT32_T + /* Unsigned 64-bit type formatter */ #undef TIFF_UINT64_FORMAT /* Unsigned 64-bit type */ #undef TIFF_UINT64_T +/* Unsigned 8-bit type */ +#undef TIFF_UINT8_T + /* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */ #undef TIME_WITH_SYS_TIME /* Define to 1 if your <sys/time.h> declares `struct tm'. */ #undef TM_IN_SYS_TIME +/* define to use win32 IO system */ +#undef USE_WIN32_FILEIO + /* Version number of package */ #undef VERSION @@ -287,6 +368,11 @@ /* Support Deflate compression */ #undef ZIP_SUPPORT +/* Enable large inode numbers on Mac OS X 10.5. */ +#ifndef _DARWIN_USE_64_BIT_INODE +# define _DARWIN_USE_64_BIT_INODE 1 +#endif + /* Number of bits in a file offset, on hosts where this is settable. */ #undef _FILE_OFFSET_BITS diff --git a/src/3rdparty/libtiff/libtiff/tif_config.vc.h b/src/3rdparty/libtiff/libtiff/tif_config.vc.h index d9caecf..c297cf3 100644 --- a/src/3rdparty/libtiff/libtiff/tif_config.vc.h +++ b/src/3rdparty/libtiff/libtiff/tif_config.vc.h @@ -32,15 +32,23 @@ /* The size of a `long', as computed by sizeof. */ #define SIZEOF_LONG 4 +/* Signed 64-bit type formatter */ +#define TIFF_INT64_FORMAT "%I64d" + /* Signed 64-bit type */ #define TIFF_INT64_T signed __int64 +/* Unsigned 64-bit type formatter */ +#define TIFF_UINT64_FORMAT "%I64u" + /* Unsigned 64-bit type */ #define TIFF_UINT64_T unsigned __int64 /* Set the native cpu bit order */ #define HOST_FILLORDER FILLORDER_LSB2MSB +#define snprintf _snprintf + /* Define to 1 if your processor stores words with the most significant byte first (like Motorola and SPARC, unlike Intel and VAX). */ /* #undef WORDS_BIGENDIAN */ @@ -54,3 +62,10 @@ #endif #define lfind _lfind +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_config.wince.h b/src/3rdparty/libtiff/libtiff/tif_config.wince.h index a50b016..94e92bb 100644 --- a/src/3rdparty/libtiff/libtiff/tif_config.wince.h +++ b/src/3rdparty/libtiff/libtiff/tif_config.wince.h @@ -1,4 +1,4 @@ -/* $Id: tif_config.wince.h,v 1.1 2007/01/15 18:40:39 mloskot Exp $ */ +/* $Id: tif_config.wince.h,v 1.3 2010-03-10 18:56:48 bfriesen Exp $ */ /* * TIFF library configuration header for Windows CE platform. @@ -46,9 +46,6 @@ /* The size of a `int', as computed by sizeof. */ #define SIZEOF_INT 4 -/* The size of a `long', as computed by sizeof. */ -#define SIZEOF_LONG 4 - /* Set the native cpu bit order */ #define HOST_FILLORDER FILLORDER_LSB2MSB @@ -65,3 +62,10 @@ #endif +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_dir.c b/src/3rdparty/libtiff/libtiff/tif_dir.c index 102c9a8..8bf3ea7 100644 --- a/src/3rdparty/libtiff/libtiff/tif_dir.c +++ b/src/3rdparty/libtiff/libtiff/tif_dir.c @@ -1,4 +1,4 @@ -/* $Id: tif_dir.c,v 1.75.2.2 2009-01-01 00:10:43 bfriesen Exp $ */ +/* $Id: tif_dir.c,v 1.113 2012-06-14 20:32:53 fwarmerdam Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler @@ -46,7 +46,7 @@ setByteArray(void** vpp, void* vp, size_t nmemb, size_t elem_size) if (*vpp) _TIFFfree(*vpp), *vpp = 0; if (vp) { - tsize_t bytes = nmemb * elem_size; + tmsize_t bytes = (tmsize_t)(nmemb * elem_size); if (elem_size && bytes / elem_size == nmemb) *vpp = (void*) _TIFFmalloc(bytes); if (*vpp) @@ -63,11 +63,26 @@ void _TIFFsetShortArray(uint16** wpp, uint16* wp, uint32 n) { setByteArray((void**) wpp, (void*) wp, n, sizeof (uint16)); } void _TIFFsetLongArray(uint32** lpp, uint32* lp, uint32 n) { setByteArray((void**) lpp, (void*) lp, n, sizeof (uint32)); } +void _TIFFsetLong8Array(uint64** lpp, uint64* lp, uint32 n) + { setByteArray((void**) lpp, (void*) lp, n, sizeof (uint64)); } void _TIFFsetFloatArray(float** fpp, float* fp, uint32 n) { setByteArray((void**) fpp, (void*) fp, n, sizeof (float)); } void _TIFFsetDoubleArray(double** dpp, double* dp, uint32 n) { setByteArray((void**) dpp, (void*) dp, n, sizeof (double)); } +static void +setDoubleArrayOneValue(double** vpp, double value, size_t nmemb) +{ + if (*vpp) + _TIFFfree(*vpp); + *vpp = _TIFFmalloc(nmemb*sizeof(double)); + if (*vpp) + { + while (nmemb--) + ((double*)*vpp)[nmemb] = value; + } +} + /* * Install extra samples information. */ @@ -80,7 +95,7 @@ setExtraSamples(TIFFDirectory* td, va_list ap, uint32* v) uint16* va; uint32 i; - *v = va_arg(ap, uint32); + *v = (uint16) va_arg(ap, uint16_vap); if ((uint16) *v > td->td_samplesperpixel) return 0; va = va_arg(ap, uint16*); @@ -107,6 +122,10 @@ setExtraSamples(TIFFDirectory* td, va_list ap, uint32* v) #undef EXTRASAMPLE_COREL_UNASSALPHA } +/* + * Confirm we have "samplesperpixel" ink names separated by \0. Returns + * zero if the ink names are not as expected. + */ static uint32 checkInkNamesString(TIFF* tif, uint32 slen, const char* s) { @@ -117,12 +136,12 @@ checkInkNamesString(TIFF* tif, uint32 slen, const char* s) const char* ep = s+slen; const char* cp = s; for (; i > 0; i--) { - for (; *cp != '\0'; cp++) - if (cp >= ep) - goto bad; + for (; cp < ep && *cp != '\0'; cp++) {} + if (cp >= ep) + goto bad; cp++; /* skip \0 */ } - return (cp-s); + return ((uint32)(cp-s)); } bad: TIFFErrorExt(tif->tif_clientdata, "TIFFSetField", @@ -134,7 +153,7 @@ bad: } static int -_TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap) +_TIFFVSetField(TIFF* tif, uint32 tag, va_list ap) { static const char module[] = "_TIFFVSetField"; @@ -142,19 +161,31 @@ _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap) int status = 1; uint32 v32, i, v; char* s; + const TIFFField *fip = TIFFFindField(tif, tag, TIFF_ANY); + uint32 standard_tag = tag; + + /* + * We want to force the custom code to be used for custom + * fields even if the tag happens to match a well known + * one - important for reinterpreted handling of standard + * tag values in custom directories (ie. EXIF) + */ + if (fip->field_bit == FIELD_CUSTOM) { + standard_tag = 0; + } - switch (tag) { + switch (standard_tag) { case TIFFTAG_SUBFILETYPE: - td->td_subfiletype = va_arg(ap, uint32); + td->td_subfiletype = (uint32) va_arg(ap, uint32); break; case TIFFTAG_IMAGEWIDTH: - td->td_imagewidth = va_arg(ap, uint32); + td->td_imagewidth = (uint32) va_arg(ap, uint32); break; case TIFFTAG_IMAGELENGTH: - td->td_imagelength = va_arg(ap, uint32); + td->td_imagelength = (uint32) va_arg(ap, uint32); break; case TIFFTAG_BITSPERSAMPLE: - td->td_bitspersample = (uint16) va_arg(ap, int); + td->td_bitspersample = (uint16) va_arg(ap, uint16_vap); /* * If the data require post-decoding processing to byte-swap * samples, set it up here. Note that since tags are required @@ -163,7 +194,9 @@ _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap) * work in with its normal work. */ if (tif->tif_flags & TIFF_SWAB) { - if (td->td_bitspersample == 16) + if (td->td_bitspersample == 8) + tif->tif_postdecode = _TIFFNoPostDecode; + else if (td->td_bitspersample == 16) tif->tif_postdecode = _TIFFSwab16BitData; else if (td->td_bitspersample == 24) tif->tif_postdecode = _TIFFSwab24BitData; @@ -176,14 +209,14 @@ _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap) } break; case TIFFTAG_COMPRESSION: - v = va_arg(ap, uint32) & 0xffff; + v = (uint16) va_arg(ap, uint16_vap); /* * If we're changing the compression scheme, the notify the * previous module so that it can cleanup any state it's * setup. */ if (TIFFFieldSet(tif, FIELD_COMPRESSION)) { - if (td->td_compression == v) + if ((uint32)td->td_compression == v) break; (*tif->tif_cleanup)(tif); tif->tif_flags &= ~TIFF_CODERSETUP; @@ -192,38 +225,37 @@ _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap) * Setup new compression routine state. */ if( (status = TIFFSetCompressionScheme(tif, v)) != 0 ) - td->td_compression = (uint16) v; - else - status = 0; + td->td_compression = (uint16) v; + else + status = 0; break; case TIFFTAG_PHOTOMETRIC: - td->td_photometric = (uint16) va_arg(ap, int); + td->td_photometric = (uint16) va_arg(ap, uint16_vap); break; case TIFFTAG_THRESHHOLDING: - td->td_threshholding = (uint16) va_arg(ap, int); + td->td_threshholding = (uint16) va_arg(ap, uint16_vap); break; case TIFFTAG_FILLORDER: - v = va_arg(ap, uint32); + v = (uint16) va_arg(ap, uint16_vap); if (v != FILLORDER_LSB2MSB && v != FILLORDER_MSB2LSB) goto badvalue; td->td_fillorder = (uint16) v; break; case TIFFTAG_ORIENTATION: - v = va_arg(ap, uint32); + v = (uint16) va_arg(ap, uint16_vap); if (v < ORIENTATION_TOPLEFT || ORIENTATION_LEFTBOT < v) goto badvalue; else td->td_orientation = (uint16) v; break; case TIFFTAG_SAMPLESPERPIXEL: - /* XXX should cross check -- e.g. if pallette, then 1 */ - v = va_arg(ap, uint32); + v = (uint16) va_arg(ap, uint16_vap); if (v == 0) goto badvalue; td->td_samplesperpixel = (uint16) v; break; case TIFFTAG_ROWSPERSTRIP: - v32 = va_arg(ap, uint32); + v32 = (uint32) va_arg(ap, uint32); if (v32 == 0) goto badvalue32; td->td_rowsperstrip = v32; @@ -233,16 +265,22 @@ _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap) } break; case TIFFTAG_MINSAMPLEVALUE: - td->td_minsamplevalue = (uint16) va_arg(ap, int); + td->td_minsamplevalue = (uint16) va_arg(ap, uint16_vap); break; case TIFFTAG_MAXSAMPLEVALUE: - td->td_maxsamplevalue = (uint16) va_arg(ap, int); + td->td_maxsamplevalue = (uint16) va_arg(ap, uint16_vap); break; case TIFFTAG_SMINSAMPLEVALUE: - td->td_sminsamplevalue = va_arg(ap, double); + if (tif->tif_flags & TIFF_PERSAMPLE) + _TIFFsetDoubleArray(&td->td_sminsamplevalue, va_arg(ap, double*), td->td_samplesperpixel); + else + setDoubleArrayOneValue(&td->td_sminsamplevalue, va_arg(ap, double), td->td_samplesperpixel); break; case TIFFTAG_SMAXSAMPLEVALUE: - td->td_smaxsamplevalue = va_arg(ap, double); + if (tif->tif_flags & TIFF_PERSAMPLE) + _TIFFsetDoubleArray(&td->td_smaxsamplevalue, va_arg(ap, double*), td->td_samplesperpixel); + else + setDoubleArrayOneValue(&td->td_smaxsamplevalue, va_arg(ap, double), td->td_samplesperpixel); break; case TIFFTAG_XRESOLUTION: td->td_xresolution = (float) va_arg(ap, double); @@ -251,7 +289,7 @@ _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap) td->td_yresolution = (float) va_arg(ap, double); break; case TIFFTAG_PLANARCONFIG: - v = va_arg(ap, uint32); + v = (uint16) va_arg(ap, uint16_vap); if (v != PLANARCONFIG_CONTIG && v != PLANARCONFIG_SEPARATE) goto badvalue; td->td_planarconfig = (uint16) v; @@ -263,18 +301,18 @@ _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap) td->td_yposition = (float) va_arg(ap, double); break; case TIFFTAG_RESOLUTIONUNIT: - v = va_arg(ap, uint32); + v = (uint16) va_arg(ap, uint16_vap); if (v < RESUNIT_NONE || RESUNIT_CENTIMETER < v) goto badvalue; td->td_resolutionunit = (uint16) v; break; case TIFFTAG_PAGENUMBER: - td->td_pagenumber[0] = (uint16) va_arg(ap, int); - td->td_pagenumber[1] = (uint16) va_arg(ap, int); + td->td_pagenumber[0] = (uint16) va_arg(ap, uint16_vap); + td->td_pagenumber[1] = (uint16) va_arg(ap, uint16_vap); break; case TIFFTAG_HALFTONEHINTS: - td->td_halftonehints[0] = (uint16) va_arg(ap, int); - td->td_halftonehints[1] = (uint16) va_arg(ap, int); + td->td_halftonehints[0] = (uint16) va_arg(ap, uint16_vap); + td->td_halftonehints[1] = (uint16) va_arg(ap, uint16_vap); break; case TIFFTAG_COLORMAP: v32 = (uint32)(1L<<td->td_bitspersample); @@ -287,14 +325,14 @@ _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap) goto badvalue; break; case TIFFTAG_MATTEING: - td->td_extrasamples = (uint16) (va_arg(ap, int) != 0); + td->td_extrasamples = (((uint16) va_arg(ap, uint16_vap)) != 0); if (td->td_extrasamples) { uint16 sv = EXTRASAMPLE_ASSOCALPHA; _TIFFsetShortArray(&td->td_sampleinfo, &sv, 1); } break; case TIFFTAG_TILEWIDTH: - v32 = va_arg(ap, uint32); + v32 = (uint32) va_arg(ap, uint32); if (v32 % 16) { if (tif->tif_mode != O_RDONLY) goto badvalue32; @@ -305,7 +343,7 @@ _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap) tif->tif_flags |= TIFF_ISTILED; break; case TIFFTAG_TILELENGTH: - v32 = va_arg(ap, uint32); + v32 = (uint32) va_arg(ap, uint32); if (v32 % 16) { if (tif->tif_mode != O_RDONLY) goto badvalue32; @@ -316,13 +354,13 @@ _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap) tif->tif_flags |= TIFF_ISTILED; break; case TIFFTAG_TILEDEPTH: - v32 = va_arg(ap, uint32); + v32 = (uint32) va_arg(ap, uint32); if (v32 == 0) goto badvalue32; td->td_tiledepth = v32; break; case TIFFTAG_DATATYPE: - v = va_arg(ap, uint32); + v = (uint16) va_arg(ap, uint16_vap); switch (v) { case DATATYPE_VOID: v = SAMPLEFORMAT_VOID; break; case DATATYPE_INT: v = SAMPLEFORMAT_INT; break; @@ -333,29 +371,29 @@ _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap) td->td_sampleformat = (uint16) v; break; case TIFFTAG_SAMPLEFORMAT: - v = va_arg(ap, uint32); + v = (uint16) va_arg(ap, uint16_vap); if (v < SAMPLEFORMAT_UINT || SAMPLEFORMAT_COMPLEXIEEEFP < v) goto badvalue; td->td_sampleformat = (uint16) v; - /* Try to fix up the SWAB function for complex data. */ - if( td->td_sampleformat == SAMPLEFORMAT_COMPLEXINT - && td->td_bitspersample == 32 - && tif->tif_postdecode == _TIFFSwab32BitData ) - tif->tif_postdecode = _TIFFSwab16BitData; - else if( (td->td_sampleformat == SAMPLEFORMAT_COMPLEXINT - || td->td_sampleformat == SAMPLEFORMAT_COMPLEXIEEEFP) - && td->td_bitspersample == 64 - && tif->tif_postdecode == _TIFFSwab64BitData ) - tif->tif_postdecode = _TIFFSwab32BitData; + /* Try to fix up the SWAB function for complex data. */ + if( td->td_sampleformat == SAMPLEFORMAT_COMPLEXINT + && td->td_bitspersample == 32 + && tif->tif_postdecode == _TIFFSwab32BitData ) + tif->tif_postdecode = _TIFFSwab16BitData; + else if( (td->td_sampleformat == SAMPLEFORMAT_COMPLEXINT + || td->td_sampleformat == SAMPLEFORMAT_COMPLEXIEEEFP) + && td->td_bitspersample == 64 + && tif->tif_postdecode == _TIFFSwab64BitData ) + tif->tif_postdecode = _TIFFSwab32BitData; break; case TIFFTAG_IMAGEDEPTH: - td->td_imagedepth = va_arg(ap, uint32); + td->td_imagedepth = (uint32) va_arg(ap, uint32); break; case TIFFTAG_SUBIFD: if ((tif->tif_flags & TIFF_INSUBIFD) == 0) { - td->td_nsubifd = (uint16) va_arg(ap, int); - _TIFFsetLongArray(&td->td_subifd, va_arg(ap, uint32*), + td->td_nsubifd = (uint16) va_arg(ap, uint16_vap); + _TIFFsetLong8Array(&td->td_subifd, (uint64*) va_arg(ap, uint64*), (long) td->td_nsubifd); } else { TIFFErrorExt(tif->tif_clientdata, module, @@ -365,11 +403,11 @@ _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap) } break; case TIFFTAG_YCBCRPOSITIONING: - td->td_ycbcrpositioning = (uint16) va_arg(ap, int); + td->td_ycbcrpositioning = (uint16) va_arg(ap, uint16_vap); break; case TIFFTAG_YCBCRSUBSAMPLING: - td->td_ycbcrsubsampling[0] = (uint16) va_arg(ap, int); - td->td_ycbcrsubsampling[1] = (uint16) va_arg(ap, int); + td->td_ycbcrsubsampling[0] = (uint16) va_arg(ap, uint16_vap); + td->td_ycbcrsubsampling[1] = (uint16) va_arg(ap, uint16_vap); break; case TIFFTAG_TRANSFERFUNCTION: v = (td->td_samplesperpixel - td->td_extrasamples) > 1 ? 3 : 1; @@ -377,207 +415,258 @@ _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap) _TIFFsetShortArray(&td->td_transferfunction[i], va_arg(ap, uint16*), 1L<<td->td_bitspersample); break; + case TIFFTAG_REFERENCEBLACKWHITE: + /* XXX should check for null range */ + _TIFFsetFloatArray(&td->td_refblackwhite, va_arg(ap, float*), 6); + break; case TIFFTAG_INKNAMES: - v = va_arg(ap, uint32); + v = (uint16) va_arg(ap, uint16_vap); s = va_arg(ap, char*); v = checkInkNamesString(tif, v, s); - status = v > 0; + status = v > 0; if( v > 0 ) { _TIFFsetNString(&td->td_inknames, s, v); td->td_inknameslen = v; } break; - default: { - TIFFTagValue *tv; - int tv_size, iCustom; - const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY); - - /* - * This can happen if multiple images are open with different - * codecs which have private tags. The global tag information - * table may then have tags that are valid for one file but not - * the other. If the client tries to set a tag that is not valid - * for the image's codec then we'll arrive here. This - * happens, for example, when tiffcp is used to convert between - * compression schemes and codec-specific tags are blindly copied. - */ - if(fip == NULL || fip->field_bit != FIELD_CUSTOM) { - TIFFErrorExt(tif->tif_clientdata, module, - "%s: Invalid %stag \"%s\" (not supported by codec)", - tif->tif_name, isPseudoTag(tag) ? "pseudo-" : "", - fip ? fip->field_name : "Unknown"); - status = 0; + case TIFFTAG_PERSAMPLE: + v = (uint16) va_arg(ap, uint16_vap); + if( v == PERSAMPLE_MULTI ) + tif->tif_flags |= TIFF_PERSAMPLE; + else + tif->tif_flags &= ~TIFF_PERSAMPLE; break; - } - - /* - * Find the existing entry for this custom value. - */ - tv = NULL; - for (iCustom = 0; iCustom < td->td_customValueCount; iCustom++) { - if (td->td_customValues[iCustom].info->field_tag == tag) { - tv = td->td_customValues + iCustom; - if (tv->value != NULL) { - _TIFFfree(tv->value); - tv->value = NULL; - } - break; - } - } + default: { + TIFFTagValue *tv; + int tv_size, iCustom; - /* - * Grow the custom list if the entry was not found. - */ - if(tv == NULL) { - TIFFTagValue *new_customValues; - - td->td_customValueCount++; - new_customValues = (TIFFTagValue *) - _TIFFrealloc(td->td_customValues, - sizeof(TIFFTagValue) * td->td_customValueCount); - if (!new_customValues) { + /* + * This can happen if multiple images are open with different + * codecs which have private tags. The global tag information + * table may then have tags that are valid for one file but not + * the other. If the client tries to set a tag that is not valid + * for the image's codec then we'll arrive here. This + * happens, for example, when tiffcp is used to convert between + * compression schemes and codec-specific tags are blindly copied. + */ + if(fip == NULL || fip->field_bit != FIELD_CUSTOM) { TIFFErrorExt(tif->tif_clientdata, module, - "%s: Failed to allocate space for list of custom values", - tif->tif_name); + "%s: Invalid %stag \"%s\" (not supported by codec)", + tif->tif_name, isPseudoTag(tag) ? "pseudo-" : "", + fip ? fip->field_name : "Unknown"); status = 0; - goto end; + break; } - td->td_customValues = new_customValues; + /* + * Find the existing entry for this custom value. + */ + tv = NULL; + for (iCustom = 0; iCustom < td->td_customValueCount; iCustom++) { + if (td->td_customValues[iCustom].info->field_tag == tag) { + tv = td->td_customValues + iCustom; + if (tv->value != NULL) { + _TIFFfree(tv->value); + tv->value = NULL; + } + break; + } + } - tv = td->td_customValues + (td->td_customValueCount - 1); - tv->info = fip; - tv->value = NULL; - tv->count = 0; - } + /* + * Grow the custom list if the entry was not found. + */ + if(tv == NULL) { + TIFFTagValue *new_customValues; - /* - * Set custom value ... save a copy of the custom tag value. - */ - tv_size = _TIFFDataSize(fip->field_type); - if (tv_size == 0) { - status = 0; - TIFFErrorExt(tif->tif_clientdata, module, - "%s: Bad field type %d for \"%s\"", - tif->tif_name, fip->field_type, - fip->field_name); - goto end; - } - - if(fip->field_passcount) { - if (fip->field_writecount == TIFF_VARIABLE2) - tv->count = (uint32) va_arg(ap, uint32); - else - tv->count = (int) va_arg(ap, int); - } else if (fip->field_writecount == TIFF_VARIABLE - || fip->field_writecount == TIFF_VARIABLE2) - tv->count = 1; - else if (fip->field_writecount == TIFF_SPP) - tv->count = td->td_samplesperpixel; - else - tv->count = fip->field_writecount; - - - if (fip->field_type == TIFF_ASCII) - _TIFFsetString((char **)&tv->value, va_arg(ap, char *)); - else { - tv->value = _TIFFCheckMalloc(tif, tv_size, tv->count, - "Tag Value"); - if (!tv->value) { - status = 0; - goto end; + td->td_customValueCount++; + new_customValues = (TIFFTagValue *) + _TIFFrealloc(td->td_customValues, + sizeof(TIFFTagValue) * td->td_customValueCount); + if (!new_customValues) { + TIFFErrorExt(tif->tif_clientdata, module, + "%s: Failed to allocate space for list of custom values", + tif->tif_name); + status = 0; + goto end; + } + + td->td_customValues = new_customValues; + + tv = td->td_customValues + (td->td_customValueCount - 1); + tv->info = fip; + tv->value = NULL; + tv->count = 0; } - if ((fip->field_passcount - || fip->field_writecount == TIFF_VARIABLE - || fip->field_writecount == TIFF_VARIABLE2 - || fip->field_writecount == TIFF_SPP - || tv->count > 1) - && fip->field_tag != TIFFTAG_PAGENUMBER - && fip->field_tag != TIFFTAG_HALFTONEHINTS - && fip->field_tag != TIFFTAG_YCBCRSUBSAMPLING - && fip->field_tag != TIFFTAG_DOTRANGE) { - _TIFFmemcpy(tv->value, va_arg(ap, void *), - tv->count * tv_size); - } else { - /* - * XXX: The following loop required to handle - * TIFFTAG_PAGENUMBER, TIFFTAG_HALFTONEHINTS, - * TIFFTAG_YCBCRSUBSAMPLING and TIFFTAG_DOTRANGE tags. - * These tags are actually arrays and should be passed as - * array pointers to TIFFSetField() function, but actually - * passed as a list of separate values. This behaviour - * must be changed in the future! - */ - int i; - char *val = (char *)tv->value; - - for (i = 0; i < tv->count; i++, val += tv_size) { - switch (fip->field_type) { + /* + * Set custom value ... save a copy of the custom tag value. + */ + tv_size = _TIFFDataSize(fip->field_type); + if (tv_size == 0) { + status = 0; + TIFFErrorExt(tif->tif_clientdata, module, + "%s: Bad field type %d for \"%s\"", + tif->tif_name, fip->field_type, + fip->field_name); + goto end; + } + + if (fip->field_type == TIFF_ASCII) + { + uint32 ma; + char* mb; + if (fip->field_passcount) + { + assert(fip->field_writecount==TIFF_VARIABLE2); + ma=(uint32)va_arg(ap,uint32); + mb=(char*)va_arg(ap,char*); + } + else + { + mb=(char*)va_arg(ap,char*); + ma=(uint32)(strlen(mb)+1); + } + tv->count=ma; + setByteArray(&tv->value,mb,ma,1); + } + else + { + if (fip->field_passcount) { + if (fip->field_writecount == TIFF_VARIABLE2) + tv->count = (uint32) va_arg(ap, uint32); + else + tv->count = (int) va_arg(ap, int); + } else if (fip->field_writecount == TIFF_VARIABLE + || fip->field_writecount == TIFF_VARIABLE2) + tv->count = 1; + else if (fip->field_writecount == TIFF_SPP) + tv->count = td->td_samplesperpixel; + else + tv->count = fip->field_writecount; + + if (tv->count == 0) { + status = 0; + TIFFErrorExt(tif->tif_clientdata, module, + "%s: Null count for \"%s\" (type " + "%d, writecount %d, passcount %d)", + tif->tif_name, + fip->field_name, + fip->field_type, + fip->field_writecount, + fip->field_passcount); + goto end; + } + + tv->value = _TIFFCheckMalloc(tif, tv->count, tv_size, + "custom tag binary object"); + if (!tv->value) { + status = 0; + goto end; + } + + if (fip->field_tag == TIFFTAG_DOTRANGE + && strcmp(fip->field_name,"DotRange") == 0) { + /* TODO: This is an evil exception and should not have been + handled this way ... likely best if we move it into + the directory structure with an explicit field in + libtiff 4.1 and assign it a FIELD_ value */ + uint16 v[2]; + v[0] = (uint16)va_arg(ap, int); + v[1] = (uint16)va_arg(ap, int); + _TIFFmemcpy(tv->value, &v, 4); + } + + else if (fip->field_passcount + || fip->field_writecount == TIFF_VARIABLE + || fip->field_writecount == TIFF_VARIABLE2 + || fip->field_writecount == TIFF_SPP + || tv->count > 1) { + _TIFFmemcpy(tv->value, va_arg(ap, void *), + tv->count * tv_size); + } else { + char *val = (char *)tv->value; + assert( tv->count == 1 ); + + switch (fip->field_type) { case TIFF_BYTE: case TIFF_UNDEFINED: - { - uint8 v = (uint8)va_arg(ap, int); - _TIFFmemcpy(val, &v, tv_size); - } - break; + { + uint8 v = (uint8)va_arg(ap, int); + _TIFFmemcpy(val, &v, tv_size); + } + break; case TIFF_SBYTE: - { - int8 v = (int8)va_arg(ap, int); - _TIFFmemcpy(val, &v, tv_size); - } - break; + { + int8 v = (int8)va_arg(ap, int); + _TIFFmemcpy(val, &v, tv_size); + } + break; case TIFF_SHORT: - { - uint16 v = (uint16)va_arg(ap, int); - _TIFFmemcpy(val, &v, tv_size); - } - break; + { + uint16 v = (uint16)va_arg(ap, int); + _TIFFmemcpy(val, &v, tv_size); + } + break; case TIFF_SSHORT: - { - int16 v = (int16)va_arg(ap, int); - _TIFFmemcpy(val, &v, tv_size); - } - break; + { + int16 v = (int16)va_arg(ap, int); + _TIFFmemcpy(val, &v, tv_size); + } + break; case TIFF_LONG: case TIFF_IFD: - { - uint32 v = va_arg(ap, uint32); - _TIFFmemcpy(val, &v, tv_size); - } - break; + { + uint32 v = va_arg(ap, uint32); + _TIFFmemcpy(val, &v, tv_size); + } + break; case TIFF_SLONG: - { - int32 v = va_arg(ap, int32); - _TIFFmemcpy(val, &v, tv_size); - } - break; + { + int32 v = va_arg(ap, int32); + _TIFFmemcpy(val, &v, tv_size); + } + break; + case TIFF_LONG8: + case TIFF_IFD8: + { + uint64 v = va_arg(ap, uint64); + _TIFFmemcpy(val, &v, tv_size); + } + break; + case TIFF_SLONG8: + { + int64 v = va_arg(ap, int64); + _TIFFmemcpy(val, &v, tv_size); + } + break; case TIFF_RATIONAL: case TIFF_SRATIONAL: case TIFF_FLOAT: - { - float v = (float)va_arg(ap, double); - _TIFFmemcpy(val, &v, tv_size); - } - break; + { + float v = (float)va_arg(ap, double); + _TIFFmemcpy(val, &v, tv_size); + } + break; case TIFF_DOUBLE: - { - double v = va_arg(ap, double); - _TIFFmemcpy(val, &v, tv_size); - } - break; + { + double v = va_arg(ap, double); + _TIFFmemcpy(val, &v, tv_size); + } + break; default: - _TIFFmemset(val, 0, tv_size); - status = 0; - break; - } - } + _TIFFmemset(val, 0, tv_size); + status = 0; + break; + } + } } - } - } + } } if (status) { - TIFFSetFieldBit(tif, _TIFFFieldWithTag(tif, tag)->field_bit); + const TIFFField* fip=TIFFFieldWithTag(tif,tag); + if (fip) + TIFFSetFieldBit(tif, fip->field_bit); tif->tif_flags |= TIFF_DIRTYDIRECT; } @@ -585,18 +674,24 @@ end: va_end(ap); return (status); badvalue: - TIFFErrorExt(tif->tif_clientdata, module, - "%s: Bad value %d for \"%s\" tag", + { + const TIFFField* fip=TIFFFieldWithTag(tif,tag); + TIFFErrorExt(tif->tif_clientdata, module, + "%s: Bad value %u for \"%s\" tag", tif->tif_name, v, - _TIFFFieldWithTag(tif, tag)->field_name); - va_end(ap); + fip ? fip->field_name : "Unknown"); + va_end(ap); + } return (0); badvalue32: - TIFFErrorExt(tif->tif_clientdata, module, + { + const TIFFField* fip=TIFFFieldWithTag(tif,tag); + TIFFErrorExt(tif->tif_clientdata, module, "%s: Bad value %u for \"%s\" tag", tif->tif_name, v32, - _TIFFFieldWithTag(tif, tag)->field_name); - va_end(ap); + fip ? fip->field_name : "Unknown"); + va_end(ap); + } return (0); } @@ -610,9 +705,9 @@ badvalue32: * on the format of the data that is written. */ static int -OkToChangeTag(TIFF* tif, ttag_t tag) +OkToChangeTag(TIFF* tif, uint32 tag) { - const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY); + const TIFFField* fip = TIFFFindField(tif, tag, TIFF_ANY); if (!fip) { /* unknown tag */ TIFFErrorExt(tif->tif_clientdata, "TIFFSetField", "%s: Unknown %stag %u", tif->tif_name, isPseudoTag(tag) ? "pseudo-" : "", tag); @@ -642,7 +737,7 @@ OkToChangeTag(TIFF* tif, ttag_t tag) * updated. */ int -TIFFSetField(TIFF* tif, ttag_t tag, ...) +TIFFSetField(TIFF* tif, uint32 tag, ...) { va_list ap; int status; @@ -654,286 +749,379 @@ TIFFSetField(TIFF* tif, ttag_t tag, ...) } /* + * Clear the contents of the field in the internal structure. + */ +int +TIFFUnsetField(TIFF* tif, uint32 tag) +{ + const TIFFField *fip = TIFFFieldWithTag(tif, tag); + TIFFDirectory* td = &tif->tif_dir; + + if( !fip ) + return 0; + + if( fip->field_bit != FIELD_CUSTOM ) + TIFFClrFieldBit(tif, fip->field_bit); + else + { + TIFFTagValue *tv = NULL; + int i; + + for (i = 0; i < td->td_customValueCount; i++) { + + tv = td->td_customValues + i; + if( tv->info->field_tag == tag ) + break; + } + + if( i < td->td_customValueCount ) + { + _TIFFfree(tv->value); + for( ; i < td->td_customValueCount-1; i++) { + td->td_customValues[i] = td->td_customValues[i+1]; + } + td->td_customValueCount--; + } + } + + tif->tif_flags |= TIFF_DIRTYDIRECT; + + return (1); +} + +/* * Like TIFFSetField, but taking a varargs * parameter list. This routine is useful * for building higher-level interfaces on * top of the library. */ int -TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap) +TIFFVSetField(TIFF* tif, uint32 tag, va_list ap) { return OkToChangeTag(tif, tag) ? (*tif->tif_tagmethods.vsetfield)(tif, tag, ap) : 0; } static int -_TIFFVGetField(TIFF* tif, ttag_t tag, va_list ap) +_TIFFVGetField(TIFF* tif, uint32 tag, va_list ap) { - TIFFDirectory* td = &tif->tif_dir; - int ret_val = 1; + TIFFDirectory* td = &tif->tif_dir; + int ret_val = 1; + uint32 standard_tag = tag; + const TIFFField* fip = TIFFFindField(tif, tag, TIFF_ANY); + + /* + * We want to force the custom code to be used for custom + * fields even if the tag happens to match a well known + * one - important for reinterpreted handling of standard + * tag values in custom directories (ie. EXIF) + */ + if (fip->field_bit == FIELD_CUSTOM) { + standard_tag = 0; + } - switch (tag) { - case TIFFTAG_SUBFILETYPE: - *va_arg(ap, uint32*) = td->td_subfiletype; - break; - case TIFFTAG_IMAGEWIDTH: - *va_arg(ap, uint32*) = td->td_imagewidth; - break; - case TIFFTAG_IMAGELENGTH: - *va_arg(ap, uint32*) = td->td_imagelength; - break; - case TIFFTAG_BITSPERSAMPLE: - *va_arg(ap, uint16*) = td->td_bitspersample; - break; - case TIFFTAG_COMPRESSION: - *va_arg(ap, uint16*) = td->td_compression; - break; - case TIFFTAG_PHOTOMETRIC: - *va_arg(ap, uint16*) = td->td_photometric; - break; - case TIFFTAG_THRESHHOLDING: - *va_arg(ap, uint16*) = td->td_threshholding; - break; - case TIFFTAG_FILLORDER: - *va_arg(ap, uint16*) = td->td_fillorder; - break; - case TIFFTAG_ORIENTATION: - *va_arg(ap, uint16*) = td->td_orientation; - break; - case TIFFTAG_SAMPLESPERPIXEL: - *va_arg(ap, uint16*) = td->td_samplesperpixel; - break; - case TIFFTAG_ROWSPERSTRIP: - *va_arg(ap, uint32*) = td->td_rowsperstrip; - break; - case TIFFTAG_MINSAMPLEVALUE: - *va_arg(ap, uint16*) = td->td_minsamplevalue; - break; - case TIFFTAG_MAXSAMPLEVALUE: - *va_arg(ap, uint16*) = td->td_maxsamplevalue; - break; - case TIFFTAG_SMINSAMPLEVALUE: - *va_arg(ap, double*) = td->td_sminsamplevalue; - break; - case TIFFTAG_SMAXSAMPLEVALUE: - *va_arg(ap, double*) = td->td_smaxsamplevalue; - break; - case TIFFTAG_XRESOLUTION: - *va_arg(ap, float*) = td->td_xresolution; - break; - case TIFFTAG_YRESOLUTION: - *va_arg(ap, float*) = td->td_yresolution; - break; - case TIFFTAG_PLANARCONFIG: - *va_arg(ap, uint16*) = td->td_planarconfig; - break; - case TIFFTAG_XPOSITION: - *va_arg(ap, float*) = td->td_xposition; - break; - case TIFFTAG_YPOSITION: - *va_arg(ap, float*) = td->td_yposition; - break; - case TIFFTAG_RESOLUTIONUNIT: - *va_arg(ap, uint16*) = td->td_resolutionunit; - break; - case TIFFTAG_PAGENUMBER: - *va_arg(ap, uint16*) = td->td_pagenumber[0]; - *va_arg(ap, uint16*) = td->td_pagenumber[1]; - break; - case TIFFTAG_HALFTONEHINTS: - *va_arg(ap, uint16*) = td->td_halftonehints[0]; - *va_arg(ap, uint16*) = td->td_halftonehints[1]; - break; - case TIFFTAG_COLORMAP: - *va_arg(ap, uint16**) = td->td_colormap[0]; - *va_arg(ap, uint16**) = td->td_colormap[1]; - *va_arg(ap, uint16**) = td->td_colormap[2]; - break; - case TIFFTAG_STRIPOFFSETS: - case TIFFTAG_TILEOFFSETS: - *va_arg(ap, uint32**) = td->td_stripoffset; - break; - case TIFFTAG_STRIPBYTECOUNTS: - case TIFFTAG_TILEBYTECOUNTS: - *va_arg(ap, uint32**) = td->td_stripbytecount; - break; - case TIFFTAG_MATTEING: - *va_arg(ap, uint16*) = - (td->td_extrasamples == 1 && - td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA); - break; - case TIFFTAG_EXTRASAMPLES: - *va_arg(ap, uint16*) = td->td_extrasamples; - *va_arg(ap, uint16**) = td->td_sampleinfo; - break; - case TIFFTAG_TILEWIDTH: - *va_arg(ap, uint32*) = td->td_tilewidth; - break; - case TIFFTAG_TILELENGTH: - *va_arg(ap, uint32*) = td->td_tilelength; - break; - case TIFFTAG_TILEDEPTH: - *va_arg(ap, uint32*) = td->td_tiledepth; - break; - case TIFFTAG_DATATYPE: - switch (td->td_sampleformat) { - case SAMPLEFORMAT_UINT: - *va_arg(ap, uint16*) = DATATYPE_UINT; - break; - case SAMPLEFORMAT_INT: - *va_arg(ap, uint16*) = DATATYPE_INT; - break; - case SAMPLEFORMAT_IEEEFP: - *va_arg(ap, uint16*) = DATATYPE_IEEEFP; - break; - case SAMPLEFORMAT_VOID: - *va_arg(ap, uint16*) = DATATYPE_VOID; - break; - } - break; - case TIFFTAG_SAMPLEFORMAT: - *va_arg(ap, uint16*) = td->td_sampleformat; - break; - case TIFFTAG_IMAGEDEPTH: - *va_arg(ap, uint32*) = td->td_imagedepth; - break; - case TIFFTAG_SUBIFD: - *va_arg(ap, uint16*) = td->td_nsubifd; - *va_arg(ap, uint32**) = td->td_subifd; - break; - case TIFFTAG_YCBCRPOSITIONING: - *va_arg(ap, uint16*) = td->td_ycbcrpositioning; - break; - case TIFFTAG_YCBCRSUBSAMPLING: - *va_arg(ap, uint16*) = td->td_ycbcrsubsampling[0]; - *va_arg(ap, uint16*) = td->td_ycbcrsubsampling[1]; - break; - case TIFFTAG_TRANSFERFUNCTION: - *va_arg(ap, uint16**) = td->td_transferfunction[0]; - if (td->td_samplesperpixel - td->td_extrasamples > 1) { - *va_arg(ap, uint16**) = td->td_transferfunction[1]; - *va_arg(ap, uint16**) = td->td_transferfunction[2]; - } - break; - case TIFFTAG_INKNAMES: - *va_arg(ap, char**) = td->td_inknames; - break; - default: - { - const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY); - int i; - - /* - * This can happen if multiple images are open with different - * codecs which have private tags. The global tag information - * table may then have tags that are valid for one file but not - * the other. If the client tries to get a tag that is not valid - * for the image's codec then we'll arrive here. - */ - if( fip == NULL || fip->field_bit != FIELD_CUSTOM ) - { - TIFFErrorExt(tif->tif_clientdata, "_TIFFVGetField", - "%s: Invalid %stag \"%s\" " - "(not supported by codec)", - tif->tif_name, - isPseudoTag(tag) ? "pseudo-" : "", - fip ? fip->field_name : "Unknown"); - ret_val = 0; - break; - } + switch (standard_tag) { + case TIFFTAG_SUBFILETYPE: + *va_arg(ap, uint32*) = td->td_subfiletype; + break; + case TIFFTAG_IMAGEWIDTH: + *va_arg(ap, uint32*) = td->td_imagewidth; + break; + case TIFFTAG_IMAGELENGTH: + *va_arg(ap, uint32*) = td->td_imagelength; + break; + case TIFFTAG_BITSPERSAMPLE: + *va_arg(ap, uint16*) = td->td_bitspersample; + break; + case TIFFTAG_COMPRESSION: + *va_arg(ap, uint16*) = td->td_compression; + break; + case TIFFTAG_PHOTOMETRIC: + *va_arg(ap, uint16*) = td->td_photometric; + break; + case TIFFTAG_THRESHHOLDING: + *va_arg(ap, uint16*) = td->td_threshholding; + break; + case TIFFTAG_FILLORDER: + *va_arg(ap, uint16*) = td->td_fillorder; + break; + case TIFFTAG_ORIENTATION: + *va_arg(ap, uint16*) = td->td_orientation; + break; + case TIFFTAG_SAMPLESPERPIXEL: + *va_arg(ap, uint16*) = td->td_samplesperpixel; + break; + case TIFFTAG_ROWSPERSTRIP: + *va_arg(ap, uint32*) = td->td_rowsperstrip; + break; + case TIFFTAG_MINSAMPLEVALUE: + *va_arg(ap, uint16*) = td->td_minsamplevalue; + break; + case TIFFTAG_MAXSAMPLEVALUE: + *va_arg(ap, uint16*) = td->td_maxsamplevalue; + break; + case TIFFTAG_SMINSAMPLEVALUE: + if (tif->tif_flags & TIFF_PERSAMPLE) + *va_arg(ap, double**) = td->td_sminsamplevalue; + else + { + /* libtiff historially treats this as a single value. */ + uint16 i; + double v = td->td_sminsamplevalue[0]; + for (i=1; i < td->td_samplesperpixel; ++i) + if( td->td_sminsamplevalue[i] < v ) + v = td->td_sminsamplevalue[i]; + *va_arg(ap, double*) = v; + } + break; + case TIFFTAG_SMAXSAMPLEVALUE: + if (tif->tif_flags & TIFF_PERSAMPLE) + *va_arg(ap, double**) = td->td_smaxsamplevalue; + else + { + /* libtiff historially treats this as a single value. */ + uint16 i; + double v = td->td_smaxsamplevalue[0]; + for (i=1; i < td->td_samplesperpixel; ++i) + if( td->td_smaxsamplevalue[i] > v ) + v = td->td_smaxsamplevalue[i]; + *va_arg(ap, double*) = v; + } + break; + case TIFFTAG_XRESOLUTION: + *va_arg(ap, float*) = td->td_xresolution; + break; + case TIFFTAG_YRESOLUTION: + *va_arg(ap, float*) = td->td_yresolution; + break; + case TIFFTAG_PLANARCONFIG: + *va_arg(ap, uint16*) = td->td_planarconfig; + break; + case TIFFTAG_XPOSITION: + *va_arg(ap, float*) = td->td_xposition; + break; + case TIFFTAG_YPOSITION: + *va_arg(ap, float*) = td->td_yposition; + break; + case TIFFTAG_RESOLUTIONUNIT: + *va_arg(ap, uint16*) = td->td_resolutionunit; + break; + case TIFFTAG_PAGENUMBER: + *va_arg(ap, uint16*) = td->td_pagenumber[0]; + *va_arg(ap, uint16*) = td->td_pagenumber[1]; + break; + case TIFFTAG_HALFTONEHINTS: + *va_arg(ap, uint16*) = td->td_halftonehints[0]; + *va_arg(ap, uint16*) = td->td_halftonehints[1]; + break; + case TIFFTAG_COLORMAP: + *va_arg(ap, uint16**) = td->td_colormap[0]; + *va_arg(ap, uint16**) = td->td_colormap[1]; + *va_arg(ap, uint16**) = td->td_colormap[2]; + break; + case TIFFTAG_STRIPOFFSETS: + case TIFFTAG_TILEOFFSETS: + _TIFFFillStriles( tif ); + *va_arg(ap, uint64**) = td->td_stripoffset; + break; + case TIFFTAG_STRIPBYTECOUNTS: + case TIFFTAG_TILEBYTECOUNTS: + _TIFFFillStriles( tif ); + *va_arg(ap, uint64**) = td->td_stripbytecount; + break; + case TIFFTAG_MATTEING: + *va_arg(ap, uint16*) = + (td->td_extrasamples == 1 && + td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA); + break; + case TIFFTAG_EXTRASAMPLES: + *va_arg(ap, uint16*) = td->td_extrasamples; + *va_arg(ap, uint16**) = td->td_sampleinfo; + break; + case TIFFTAG_TILEWIDTH: + *va_arg(ap, uint32*) = td->td_tilewidth; + break; + case TIFFTAG_TILELENGTH: + *va_arg(ap, uint32*) = td->td_tilelength; + break; + case TIFFTAG_TILEDEPTH: + *va_arg(ap, uint32*) = td->td_tiledepth; + break; + case TIFFTAG_DATATYPE: + switch (td->td_sampleformat) { + case SAMPLEFORMAT_UINT: + *va_arg(ap, uint16*) = DATATYPE_UINT; + break; + case SAMPLEFORMAT_INT: + *va_arg(ap, uint16*) = DATATYPE_INT; + break; + case SAMPLEFORMAT_IEEEFP: + *va_arg(ap, uint16*) = DATATYPE_IEEEFP; + break; + case SAMPLEFORMAT_VOID: + *va_arg(ap, uint16*) = DATATYPE_VOID; + break; + } + break; + case TIFFTAG_SAMPLEFORMAT: + *va_arg(ap, uint16*) = td->td_sampleformat; + break; + case TIFFTAG_IMAGEDEPTH: + *va_arg(ap, uint32*) = td->td_imagedepth; + break; + case TIFFTAG_SUBIFD: + *va_arg(ap, uint16*) = td->td_nsubifd; + *va_arg(ap, uint64**) = td->td_subifd; + break; + case TIFFTAG_YCBCRPOSITIONING: + *va_arg(ap, uint16*) = td->td_ycbcrpositioning; + break; + case TIFFTAG_YCBCRSUBSAMPLING: + *va_arg(ap, uint16*) = td->td_ycbcrsubsampling[0]; + *va_arg(ap, uint16*) = td->td_ycbcrsubsampling[1]; + break; + case TIFFTAG_TRANSFERFUNCTION: + *va_arg(ap, uint16**) = td->td_transferfunction[0]; + if (td->td_samplesperpixel - td->td_extrasamples > 1) { + *va_arg(ap, uint16**) = td->td_transferfunction[1]; + *va_arg(ap, uint16**) = td->td_transferfunction[2]; + } + break; + case TIFFTAG_REFERENCEBLACKWHITE: + *va_arg(ap, float**) = td->td_refblackwhite; + break; + case TIFFTAG_INKNAMES: + *va_arg(ap, char**) = td->td_inknames; + break; + default: + { + int i; - /* - * Do we have a custom value? - */ - ret_val = 0; - for (i = 0; i < td->td_customValueCount; i++) { - TIFFTagValue *tv = td->td_customValues + i; + /* + * This can happen if multiple images are open + * with different codecs which have private + * tags. The global tag information table may + * then have tags that are valid for one file + * but not the other. If the client tries to + * get a tag that is not valid for the image's + * codec then we'll arrive here. + */ + if( fip == NULL || fip->field_bit != FIELD_CUSTOM ) + { + TIFFErrorExt(tif->tif_clientdata, "_TIFFVGetField", + "%s: Invalid %stag \"%s\" " + "(not supported by codec)", + tif->tif_name, + isPseudoTag(tag) ? "pseudo-" : "", + fip ? fip->field_name : "Unknown"); + ret_val = 0; + break; + } - if (tv->info->field_tag != tag) - continue; - - if (fip->field_passcount) { - if (fip->field_readcount == TIFF_VARIABLE2) - *va_arg(ap, uint32*) = (uint32)tv->count; - else /* Assume TIFF_VARIABLE */ - *va_arg(ap, uint16*) = (uint16)tv->count; - *va_arg(ap, void **) = tv->value; - ret_val = 1; - } else { - if ((fip->field_type == TIFF_ASCII - || fip->field_readcount == TIFF_VARIABLE - || fip->field_readcount == TIFF_VARIABLE2 - || fip->field_readcount == TIFF_SPP - || tv->count > 1) - && fip->field_tag != TIFFTAG_PAGENUMBER - && fip->field_tag != TIFFTAG_HALFTONEHINTS - && fip->field_tag != TIFFTAG_YCBCRSUBSAMPLING - && fip->field_tag != TIFFTAG_DOTRANGE) { - *va_arg(ap, void **) = tv->value; - ret_val = 1; - } else { - int j; - char *val = (char *)tv->value; + /* + * Do we have a custom value? + */ + ret_val = 0; + for (i = 0; i < td->td_customValueCount; i++) { + TIFFTagValue *tv = td->td_customValues + i; - for (j = 0; j < tv->count; - j++, val += _TIFFDataSize(tv->info->field_type)) { - switch (fip->field_type) { - case TIFF_BYTE: - case TIFF_UNDEFINED: - *va_arg(ap, uint8*) = - *(uint8 *)val; - ret_val = 1; - break; - case TIFF_SBYTE: - *va_arg(ap, int8*) = - *(int8 *)val; - ret_val = 1; - break; - case TIFF_SHORT: - *va_arg(ap, uint16*) = - *(uint16 *)val; - ret_val = 1; - break; - case TIFF_SSHORT: - *va_arg(ap, int16*) = - *(int16 *)val; - ret_val = 1; - break; - case TIFF_LONG: - case TIFF_IFD: - *va_arg(ap, uint32*) = - *(uint32 *)val; - ret_val = 1; - break; - case TIFF_SLONG: - *va_arg(ap, int32*) = - *(int32 *)val; - ret_val = 1; - break; - case TIFF_RATIONAL: - case TIFF_SRATIONAL: - case TIFF_FLOAT: - *va_arg(ap, float*) = - *(float *)val; + if (tv->info->field_tag != tag) + continue; + + if (fip->field_passcount) { + if (fip->field_readcount == TIFF_VARIABLE2) + *va_arg(ap, uint32*) = (uint32)tv->count; + else /* Assume TIFF_VARIABLE */ + *va_arg(ap, uint16*) = (uint16)tv->count; + *va_arg(ap, void **) = tv->value; ret_val = 1; - break; - case TIFF_DOUBLE: - *va_arg(ap, double*) = - *(double *)val; + } else if (fip->field_tag == TIFFTAG_DOTRANGE + && strcmp(fip->field_name,"DotRange") == 0) { + /* TODO: This is an evil exception and should not have been + handled this way ... likely best if we move it into + the directory structure with an explicit field in + libtiff 4.1 and assign it a FIELD_ value */ + *va_arg(ap, uint16*) = ((uint16 *)tv->value)[0]; + *va_arg(ap, uint16*) = ((uint16 *)tv->value)[1]; ret_val = 1; - break; - default: - ret_val = 0; - break; + } else { + if (fip->field_type == TIFF_ASCII + || fip->field_readcount == TIFF_VARIABLE + || fip->field_readcount == TIFF_VARIABLE2 + || fip->field_readcount == TIFF_SPP + || tv->count > 1) { + *va_arg(ap, void **) = tv->value; + ret_val = 1; + } else { + char *val = (char *)tv->value; + assert( tv->count == 1 ); + switch (fip->field_type) { + case TIFF_BYTE: + case TIFF_UNDEFINED: + *va_arg(ap, uint8*) = + *(uint8 *)val; + ret_val = 1; + break; + case TIFF_SBYTE: + *va_arg(ap, int8*) = + *(int8 *)val; + ret_val = 1; + break; + case TIFF_SHORT: + *va_arg(ap, uint16*) = + *(uint16 *)val; + ret_val = 1; + break; + case TIFF_SSHORT: + *va_arg(ap, int16*) = + *(int16 *)val; + ret_val = 1; + break; + case TIFF_LONG: + case TIFF_IFD: + *va_arg(ap, uint32*) = + *(uint32 *)val; + ret_val = 1; + break; + case TIFF_SLONG: + *va_arg(ap, int32*) = + *(int32 *)val; + ret_val = 1; + break; + case TIFF_LONG8: + case TIFF_IFD8: + *va_arg(ap, uint64*) = + *(uint64 *)val; + ret_val = 1; + break; + case TIFF_SLONG8: + *va_arg(ap, int64*) = + *(int64 *)val; + ret_val = 1; + break; + case TIFF_RATIONAL: + case TIFF_SRATIONAL: + case TIFF_FLOAT: + *va_arg(ap, float*) = + *(float *)val; + ret_val = 1; + break; + case TIFF_DOUBLE: + *va_arg(ap, double*) = + *(double *)val; + ret_val = 1; + break; + default: + ret_val = 0; + break; + } + } + } + break; } - } } - } - break; - } - } - } - return(ret_val); + } + return(ret_val); } /* @@ -941,7 +1129,7 @@ _TIFFVGetField(TIFF* tif, ttag_t tag, va_list ap) * internal directory structure. */ int -TIFFGetField(TIFF* tif, ttag_t tag, ...) +TIFFGetField(TIFF* tif, uint32 tag, ...) { int status; va_list ap; @@ -959,9 +1147,9 @@ TIFFGetField(TIFF* tif, ttag_t tag, ...) * top of the library. */ int -TIFFVGetField(TIFF* tif, ttag_t tag, va_list ap) +TIFFVGetField(TIFF* tif, uint32 tag, va_list ap) { - const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY); + const TIFFField* fip = TIFFFindField(tif, tag, TIFF_ANY); return (fip && (isPseudoTag(tag) || TIFFFieldSet(tif, fip->field_bit)) ? (*tif->tif_tagmethods.vgetfield)(tif, tag, ap) : 0); } @@ -983,12 +1171,15 @@ TIFFFreeDirectory(TIFF* tif) int i; _TIFFmemset(td->td_fieldsset, 0, FIELD_SETLONGS); + CleanupField(td_sminsamplevalue); + CleanupField(td_smaxsamplevalue); CleanupField(td_colormap[0]); CleanupField(td_colormap[1]); CleanupField(td_colormap[2]); CleanupField(td_sampleinfo); CleanupField(td_subifd); CleanupField(td_inknames); + CleanupField(td_refblackwhite); CleanupField(td_transferfunction[0]); CleanupField(td_transferfunction[1]); CleanupField(td_transferfunction[2]); @@ -1005,6 +1196,11 @@ TIFFFreeDirectory(TIFF* tif) td->td_customValueCount = 0; CleanupField(td_customValues); + +#if defined(DEFER_STRILE_LOAD) + _TIFFmemset( &(td->td_stripoffset_entry), 0, sizeof(TIFFDirEntry)); + _TIFFmemset( &(td->td_stripbytecount_entry), 0, sizeof(TIFFDirEntry)); +#endif } #undef CleanupField @@ -1031,14 +1227,43 @@ TIFFSetTagExtender(TIFFExtendProc extender) int TIFFCreateDirectory(TIFF* tif) { - TIFFDefaultDirectory(tif); - tif->tif_diroff = 0; - tif->tif_nextdiroff = 0; - tif->tif_curoff = 0; - tif->tif_row = (uint32) -1; - tif->tif_curstrip = (tstrip_t) -1; - - return 0; + TIFFDefaultDirectory(tif); + tif->tif_diroff = 0; + tif->tif_nextdiroff = 0; + tif->tif_curoff = 0; + tif->tif_row = (uint32) -1; + tif->tif_curstrip = (uint32) -1; + + return 0; +} + +int +TIFFCreateCustomDirectory(TIFF* tif, const TIFFFieldArray* infoarray) +{ + TIFFDefaultDirectory(tif); + + /* + * Reset the field definitions to match the application provided list. + * Hopefully TIFFDefaultDirectory() won't have done anything irreversable + * based on it's assumption this is an image directory. + */ + _TIFFSetupFields(tif, infoarray); + + tif->tif_diroff = 0; + tif->tif_nextdiroff = 0; + tif->tif_curoff = 0; + tif->tif_row = (uint32) -1; + tif->tif_curstrip = (uint32) -1; + + return 0; +} + +int +TIFFCreateEXIFDirectory(TIFF* tif) +{ + const TIFFFieldArray* exifFieldArray; + exifFieldArray = _TIFFGetExifFields(); + return TIFFCreateCustomDirectory(tif, exifFieldArray); } /* @@ -1048,11 +1273,10 @@ int TIFFDefaultDirectory(TIFF* tif) { register TIFFDirectory* td = &tif->tif_dir; + const TIFFFieldArray* tiffFieldArray; - size_t tiffFieldInfoCount; - const TIFFFieldInfo *tiffFieldInfo = - _TIFFGetFieldInfo(&tiffFieldInfoCount); - _TIFFSetupFieldInfo(tif, tiffFieldInfo, tiffFieldInfoCount); + tiffFieldArray = _TIFFGetFields(); + _TIFFSetupFields(tif, tiffFieldArray); _TIFFmemset(td, 0, sizeof (*td)); td->td_fillorder = FILLORDER_MSB2LSB; @@ -1064,16 +1288,16 @@ TIFFDefaultDirectory(TIFF* tif) td->td_tilewidth = 0; td->td_tilelength = 0; td->td_tiledepth = 1; - td->td_stripbytecountsorted = 1; /* Our own arrays always sorted. */ + td->td_stripbytecountsorted = 1; /* Our own arrays always sorted. */ td->td_resolutionunit = RESUNIT_INCH; td->td_sampleformat = SAMPLEFORMAT_UINT; td->td_imagedepth = 1; td->td_ycbcrsubsampling[0] = 2; td->td_ycbcrsubsampling[1] = 2; td->td_ycbcrpositioning = YCBCRPOSITION_CENTERED; - tif->tif_postdecode = _TIFFNoPostDecode; + tif->tif_postdecode = _TIFFNoPostDecode; tif->tif_foundfield = NULL; - tif->tif_tagmethods.vsetfield = _TIFFVSetField; + tif->tif_tagmethods.vsetfield = _TIFFVSetField; tif->tif_tagmethods.vgetfield = _TIFFVGetField; tif->tif_tagmethods.printdir = NULL; /* @@ -1104,59 +1328,138 @@ TIFFDefaultDirectory(TIFF* tif) } static int -TIFFAdvanceDirectory(TIFF* tif, uint32* nextdir, toff_t* off) +TIFFAdvanceDirectory(TIFF* tif, uint64* nextdir, uint64* off) { static const char module[] = "TIFFAdvanceDirectory"; - uint16 dircount; if (isMapped(tif)) { - toff_t poff=*nextdir; - if (poff+sizeof(uint16) > tif->tif_size) + uint64 poff=*nextdir; + if (!(tif->tif_flags&TIFF_BIGTIFF)) { - TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory count", - tif->tif_name); - return (0); + tmsize_t poffa,poffb,poffc,poffd; + uint16 dircount; + uint32 nextdir32; + poffa=(tmsize_t)poff; + poffb=poffa+sizeof(uint16); + if (((uint64)poffa!=poff)||(poffb<poffa)||(poffb<(tmsize_t)sizeof(uint16))||(poffb>tif->tif_size)) + { + TIFFErrorExt(tif->tif_clientdata,module,"Error fetching directory count"); + return(0); + } + _TIFFmemcpy(&dircount,tif->tif_base+poffa,sizeof(uint16)); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort(&dircount); + poffc=poffb+dircount*12; + poffd=poffc+sizeof(uint32); + if ((poffc<poffb)||(poffc<dircount*12)||(poffd<poffc)||(poffd<(tmsize_t)sizeof(uint32))||(poffd>tif->tif_size)) + { + TIFFErrorExt(tif->tif_clientdata,module,"Error fetching directory link"); + return(0); + } + if (off!=NULL) + *off=(uint64)poffc; + _TIFFmemcpy(&nextdir32,tif->tif_base+poffc,sizeof(uint32)); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(&nextdir32); + *nextdir=nextdir32; } - _TIFFmemcpy(&dircount, tif->tif_base+poff, sizeof (uint16)); - if (tif->tif_flags & TIFF_SWAB) - TIFFSwabShort(&dircount); - poff+=sizeof (uint16)+dircount*sizeof (TIFFDirEntry); - if (off != NULL) - *off = poff; - if (((toff_t) (poff+sizeof (uint32))) > tif->tif_size) + else { - TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory link", - tif->tif_name); - return (0); + tmsize_t poffa,poffb,poffc,poffd; + uint64 dircount64; + uint16 dircount16; + poffa=(tmsize_t)poff; + poffb=poffa+sizeof(uint64); + if (((uint64)poffa!=poff)||(poffb<poffa)||(poffb<(tmsize_t)sizeof(uint64))||(poffb>tif->tif_size)) + { + TIFFErrorExt(tif->tif_clientdata,module,"Error fetching directory count"); + return(0); + } + _TIFFmemcpy(&dircount64,tif->tif_base+poffa,sizeof(uint64)); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8(&dircount64); + if (dircount64>0xFFFF) + { + TIFFErrorExt(tif->tif_clientdata,module,"Sanity check on directory count failed"); + return(0); + } + dircount16=(uint16)dircount64; + poffc=poffb+dircount16*20; + poffd=poffc+sizeof(uint64); + if ((poffc<poffb)||(poffc<dircount16*20)||(poffd<poffc)||(poffd<(tmsize_t)sizeof(uint64))||(poffd>tif->tif_size)) + { + TIFFErrorExt(tif->tif_clientdata,module,"Error fetching directory link"); + return(0); + } + if (off!=NULL) + *off=(uint64)poffc; + _TIFFmemcpy(nextdir,tif->tif_base+poffc,sizeof(uint64)); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8(nextdir); } - _TIFFmemcpy(nextdir, tif->tif_base+poff, sizeof (uint32)); - if (tif->tif_flags & TIFF_SWAB) - TIFFSwabLong(nextdir); - return (1); + return(1); } else { - if (!SeekOK(tif, *nextdir) || - !ReadOK(tif, &dircount, sizeof (uint16))) { - TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory count", - tif->tif_name); - return (0); + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + uint16 dircount; + uint32 nextdir32; + if (!SeekOK(tif, *nextdir) || + !ReadOK(tif, &dircount, sizeof (uint16))) { + TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory count", + tif->tif_name); + return (0); + } + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabShort(&dircount); + if (off != NULL) + *off = TIFFSeekFile(tif, + dircount*12, SEEK_CUR); + else + (void) TIFFSeekFile(tif, + dircount*12, SEEK_CUR); + if (!ReadOK(tif, &nextdir32, sizeof (uint32))) { + TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory link", + tif->tif_name); + return (0); + } + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabLong(&nextdir32); + *nextdir=nextdir32; } - if (tif->tif_flags & TIFF_SWAB) - TIFFSwabShort(&dircount); - if (off != NULL) - *off = TIFFSeekFile(tif, - dircount*sizeof (TIFFDirEntry), SEEK_CUR); else - (void) TIFFSeekFile(tif, - dircount*sizeof (TIFFDirEntry), SEEK_CUR); - if (!ReadOK(tif, nextdir, sizeof (uint32))) { - TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory link", - tif->tif_name); - return (0); + { + uint64 dircount64; + uint16 dircount16; + if (!SeekOK(tif, *nextdir) || + !ReadOK(tif, &dircount64, sizeof (uint64))) { + TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory count", + tif->tif_name); + return (0); + } + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabLong8(&dircount64); + if (dircount64>0xFFFF) + { + TIFFErrorExt(tif->tif_clientdata, module, "Error fetching directory count"); + return(0); + } + dircount16 = (uint16)dircount64; + if (off != NULL) + *off = TIFFSeekFile(tif, + dircount16*20, SEEK_CUR); + else + (void) TIFFSeekFile(tif, + dircount16*20, SEEK_CUR); + if (!ReadOK(tif, nextdir, sizeof (uint64))) { + TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory link", + tif->tif_name); + return (0); + } + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabLong8(nextdir); } - if (tif->tif_flags & TIFF_SWAB) - TIFFSwabLong(nextdir); return (1); } } @@ -1164,15 +1467,19 @@ TIFFAdvanceDirectory(TIFF* tif, uint32* nextdir, toff_t* off) /* * Count the number of directories in a file. */ -tdir_t +uint16 TIFFNumberOfDirectories(TIFF* tif) { - toff_t nextdir = tif->tif_header.tiff_diroff; - tdir_t n = 0; - - while (nextdir != 0 && TIFFAdvanceDirectory(tif, &nextdir, NULL)) - n++; - return (n); + uint64 nextdir; + uint16 n; + if (!(tif->tif_flags&TIFF_BIGTIFF)) + nextdir = tif->tif_header.classic.tiff_diroff; + else + nextdir = tif->tif_header.big.tiff_diroff; + n = 0; + while (nextdir != 0 && TIFFAdvanceDirectory(tif, &nextdir, NULL)) + n++; + return (n); } /* @@ -1180,12 +1487,15 @@ TIFFNumberOfDirectories(TIFF* tif) * NB: Directories are numbered starting at 0. */ int -TIFFSetDirectory(TIFF* tif, tdir_t dirn) +TIFFSetDirectory(TIFF* tif, uint16 dirn) { - toff_t nextdir; - tdir_t n; + uint64 nextdir; + uint16 n; - nextdir = tif->tif_header.tiff_diroff; + if (!(tif->tif_flags&TIFF_BIGTIFF)) + nextdir = tif->tif_header.classic.tiff_diroff; + else + nextdir = tif->tif_header.big.tiff_diroff; for (n = dirn; n > 0 && nextdir != 0; n--) if (!TIFFAdvanceDirectory(tif, &nextdir, NULL)) return (0); @@ -1211,7 +1521,7 @@ TIFFSetDirectory(TIFF* tif, tdir_t dirn) * the SubIFD tag (e.g. thumbnail images). */ int -TIFFSetSubDirectory(TIFF* tif, uint32 diroff) +TIFFSetSubDirectory(TIFF* tif, uint64 diroff) { tif->tif_nextdiroff = diroff; /* @@ -1225,7 +1535,7 @@ TIFFSetSubDirectory(TIFF* tif, uint32 diroff) /* * Return file offset of the current directory. */ -uint32 +uint64 TIFFCurrentDirOffset(TIFF* tif) { return (tif->tif_diroff); @@ -1245,12 +1555,12 @@ TIFFLastDirectory(TIFF* tif) * Unlink the specified directory from the directory chain. */ int -TIFFUnlinkDirectory(TIFF* tif, tdir_t dirn) +TIFFUnlinkDirectory(TIFF* tif, uint16 dirn) { static const char module[] = "TIFFUnlinkDirectory"; - toff_t nextdir; - toff_t off; - tdir_t n; + uint64 nextdir; + uint64 off; + uint16 n; if (tif->tif_mode == O_RDONLY) { TIFFErrorExt(tif->tif_clientdata, module, @@ -1262,8 +1572,16 @@ TIFFUnlinkDirectory(TIFF* tif, tdir_t dirn) * to unlink and nab the offset of the link * field we'll need to patch. */ - nextdir = tif->tif_header.tiff_diroff; - off = sizeof (uint16) + sizeof (uint16); + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + nextdir = tif->tif_header.classic.tiff_diroff; + off = 4; + } + else + { + nextdir = tif->tif_header.big.tiff_diroff; + off = 8; + } for (n = dirn-1; n > 0; n--) { if (nextdir == 0) { TIFFErrorExt(tif->tif_clientdata, module, "Directory %d does not exist", dirn); @@ -1284,11 +1602,26 @@ TIFFUnlinkDirectory(TIFF* tif, tdir_t dirn) * that follows. */ (void) TIFFSeekFile(tif, off, SEEK_SET); - if (tif->tif_flags & TIFF_SWAB) - TIFFSwabLong(&nextdir); - if (!WriteOK(tif, &nextdir, sizeof (uint32))) { - TIFFErrorExt(tif->tif_clientdata, module, "Error writing directory link"); - return (0); + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + uint32 nextdir32; + nextdir32=(uint32)nextdir; + assert((uint64)nextdir32==nextdir); + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabLong(&nextdir32); + if (!WriteOK(tif, &nextdir32, sizeof (uint32))) { + TIFFErrorExt(tif->tif_clientdata, module, "Error writing directory link"); + return (0); + } + } + else + { + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabLong8(&nextdir); + if (!WriteOK(tif, &nextdir, sizeof (uint64))) { + TIFFErrorExt(tif->tif_clientdata, module, "Error writing directory link"); + return (0); + } } /* * Leave directory state setup safely. We don't have @@ -1302,68 +1635,25 @@ TIFFUnlinkDirectory(TIFF* tif, tdir_t dirn) _TIFFfree(tif->tif_rawdata); tif->tif_rawdata = NULL; tif->tif_rawcc = 0; + tif->tif_rawdataoff = 0; + tif->tif_rawdataloaded = 0; } - tif->tif_flags &= ~(TIFF_BEENWRITING|TIFF_BUFFERSETUP|TIFF_POSTENCODE); + tif->tif_flags &= ~(TIFF_BEENWRITING|TIFF_BUFFERSETUP|TIFF_POSTENCODE|TIFF_BUF4WRITE); TIFFFreeDirectory(tif); TIFFDefaultDirectory(tif); tif->tif_diroff = 0; /* force link on next write */ tif->tif_nextdiroff = 0; /* next write must be at end */ tif->tif_curoff = 0; tif->tif_row = (uint32) -1; - tif->tif_curstrip = (tstrip_t) -1; + tif->tif_curstrip = (uint32) -1; return (1); } -/* [BFC] - * - * Author: Bruce Cameron <cameron@petris.com> - * - * Set a table of tags that are to be replaced during directory process by the - * 'IGNORE' state - or return TRUE/FALSE for the requested tag such that - * 'ReadDirectory' can use the stored information. - * - * FIXME: this is never used properly. Should be removed in the future. - */ -int -TIFFReassignTagToIgnore (enum TIFFIgnoreSense task, int TIFFtagID) -{ - static int TIFFignoretags [FIELD_LAST]; - static int tagcount = 0 ; - int i; /* Loop index */ - int j; /* Loop index */ - - switch (task) - { - case TIS_STORE: - if ( tagcount < (FIELD_LAST - 1) ) - { - for ( j = 0 ; j < tagcount ; ++j ) - { /* Do not add duplicate tag */ - if ( TIFFignoretags [j] == TIFFtagID ) - return (TRUE) ; - } - TIFFignoretags [tagcount++] = TIFFtagID ; - return (TRUE) ; - } - break ; - - case TIS_EXTRACT: - for ( i = 0 ; i < tagcount ; ++i ) - { - if ( TIFFignoretags [i] == TIFFtagID ) - return (TRUE) ; - } - break; - - case TIS_EMPTY: - tagcount = 0 ; /* Clear the list */ - return (TRUE) ; - - default: - break; - } - - return (FALSE); -} - /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_dir.h b/src/3rdparty/libtiff/libtiff/tif_dir.h index e2aeea2..6af5f3d 100644 --- a/src/3rdparty/libtiff/libtiff/tif_dir.h +++ b/src/3rdparty/libtiff/libtiff/tif_dir.h @@ -1,4 +1,4 @@ -/* $Id: tif_dir.h,v 1.30.2.1 2007/04/07 14:58:30 dron Exp $ */ +/* $Id: tif_dir.h,v 1.54 2011-02-18 20:53:05 fwarmerdam Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler @@ -30,13 +30,41 @@ * ``Library-private'' Directory-related Definitions. */ +typedef struct { + const TIFFField *info; + int count; + void *value; +} TIFFTagValue; + +/* + * TIFF Image File Directories are comprised of a table of field + * descriptors of the form shown below. The table is sorted in + * ascending order by tag. The values associated with each entry are + * disjoint and may appear anywhere in the file (so long as they are + * placed on a word boundary). + * + * If the value is 4 bytes or less, in ClassicTIFF, or 8 bytes or less in + * BigTIFF, then it is placed in the offset field to save space. If so, + * it is left-justified in the offset field. + */ +typedef struct { + uint16 tdir_tag; /* see below */ + uint16 tdir_type; /* data type; see below */ + uint64 tdir_count; /* number of items; length in spec */ + union { + uint16 toff_short; + uint32 toff_long; + uint64 toff_long8; + } tdir_offset; /* either offset or the data itself if fits */ +} TIFFDirEntry; + /* * Internal format of a TIFF directory entry. */ -typedef struct { -#define FIELD_SETLONGS 4 +typedef struct { +#define FIELD_SETLONGS 4 /* bit vector of fields that are set */ - unsigned long td_fieldsset[FIELD_SETLONGS]; + unsigned long td_fieldsset[FIELD_SETLONGS]; uint32 td_imagewidth, td_imagelength, td_imagedepth; uint32 td_tilewidth, td_tilelength, td_tiledepth; @@ -51,7 +79,8 @@ typedef struct { uint16 td_samplesperpixel; uint32 td_rowsperstrip; uint16 td_minsamplevalue, td_maxsamplevalue; - double td_sminsamplevalue, td_smaxsamplevalue; + double* td_sminsamplevalue; + double* td_smaxsamplevalue; float td_xresolution, td_yresolution; uint16 td_resolutionunit; uint16 td_planarconfig; @@ -64,18 +93,23 @@ typedef struct { /* even though the name is misleading, td_stripsperimage is the number * of striles (=strips or tiles) per plane, and td_nstrips the total * number of striles */ - tstrile_t td_stripsperimage; - tstrile_t td_nstrips; /* size of offset & bytecount arrays */ - toff_t* td_stripoffset; - toff_t* td_stripbytecount; /* FIXME: it should be tsize_t array */ + uint32 td_stripsperimage; + uint32 td_nstrips; /* size of offset & bytecount arrays */ + uint64* td_stripoffset; + uint64* td_stripbytecount; int td_stripbytecountsorted; /* is the bytecount array sorted ascending? */ +#if defined(DEFER_STRILE_LOAD) + TIFFDirEntry td_stripoffset_entry; /* for deferred loading */ + TIFFDirEntry td_stripbytecount_entry; /* for deferred loading */ +#endif uint16 td_nsubifd; - uint32* td_subifd; + uint64* td_subifd; /* YCbCr parameters */ uint16 td_ycbcrsubsampling[2]; uint16 td_ycbcrpositioning; /* Colorimetry parameters */ uint16* td_transferfunction[3]; + float* td_refblackwhite; /* CMYK parameters */ int td_inknameslen; char* td_inknames; @@ -85,114 +119,178 @@ typedef struct { } TIFFDirectory; /* - * Field flags used to indicate fields that have - * been set in a directory, and to reference fields - * when manipulating a directory. + * Field flags used to indicate fields that have been set in a directory, and + * to reference fields when manipulating a directory. */ /* - * FIELD_IGNORE is used to signify tags that are to - * be processed but otherwise ignored. This permits - * antiquated tags to be quietly read and discarded. - * Note that a bit *is* allocated for ignored tags; - * this is understood by the directory reading logic - * which uses this fact to avoid special-case handling - */ -#define FIELD_IGNORE 0 + * FIELD_IGNORE is used to signify tags that are to be processed but otherwise + * ignored. This permits antiquated tags to be quietly read and discarded. + * Note that a bit *is* allocated for ignored tags; this is understood by the + * directory reading logic which uses this fact to avoid special-case handling + */ +#define FIELD_IGNORE 0 /* multi-item fields */ -#define FIELD_IMAGEDIMENSIONS 1 -#define FIELD_TILEDIMENSIONS 2 -#define FIELD_RESOLUTION 3 -#define FIELD_POSITION 4 +#define FIELD_IMAGEDIMENSIONS 1 +#define FIELD_TILEDIMENSIONS 2 +#define FIELD_RESOLUTION 3 +#define FIELD_POSITION 4 /* single-item fields */ -#define FIELD_SUBFILETYPE 5 -#define FIELD_BITSPERSAMPLE 6 -#define FIELD_COMPRESSION 7 -#define FIELD_PHOTOMETRIC 8 -#define FIELD_THRESHHOLDING 9 -#define FIELD_FILLORDER 10 -#define FIELD_ORIENTATION 15 -#define FIELD_SAMPLESPERPIXEL 16 -#define FIELD_ROWSPERSTRIP 17 -#define FIELD_MINSAMPLEVALUE 18 -#define FIELD_MAXSAMPLEVALUE 19 -#define FIELD_PLANARCONFIG 20 -#define FIELD_RESOLUTIONUNIT 22 -#define FIELD_PAGENUMBER 23 -#define FIELD_STRIPBYTECOUNTS 24 -#define FIELD_STRIPOFFSETS 25 -#define FIELD_COLORMAP 26 -#define FIELD_EXTRASAMPLES 31 -#define FIELD_SAMPLEFORMAT 32 -#define FIELD_SMINSAMPLEVALUE 33 -#define FIELD_SMAXSAMPLEVALUE 34 -#define FIELD_IMAGEDEPTH 35 -#define FIELD_TILEDEPTH 36 -#define FIELD_HALFTONEHINTS 37 -#define FIELD_YCBCRSUBSAMPLING 39 -#define FIELD_YCBCRPOSITIONING 40 -#define FIELD_TRANSFERFUNCTION 44 -#define FIELD_INKNAMES 46 -#define FIELD_SUBIFD 49 -/* FIELD_CUSTOM (see tiffio.h) 65 */ +#define FIELD_SUBFILETYPE 5 +#define FIELD_BITSPERSAMPLE 6 +#define FIELD_COMPRESSION 7 +#define FIELD_PHOTOMETRIC 8 +#define FIELD_THRESHHOLDING 9 +#define FIELD_FILLORDER 10 +#define FIELD_ORIENTATION 15 +#define FIELD_SAMPLESPERPIXEL 16 +#define FIELD_ROWSPERSTRIP 17 +#define FIELD_MINSAMPLEVALUE 18 +#define FIELD_MAXSAMPLEVALUE 19 +#define FIELD_PLANARCONFIG 20 +#define FIELD_RESOLUTIONUNIT 22 +#define FIELD_PAGENUMBER 23 +#define FIELD_STRIPBYTECOUNTS 24 +#define FIELD_STRIPOFFSETS 25 +#define FIELD_COLORMAP 26 +#define FIELD_EXTRASAMPLES 31 +#define FIELD_SAMPLEFORMAT 32 +#define FIELD_SMINSAMPLEVALUE 33 +#define FIELD_SMAXSAMPLEVALUE 34 +#define FIELD_IMAGEDEPTH 35 +#define FIELD_TILEDEPTH 36 +#define FIELD_HALFTONEHINTS 37 +#define FIELD_YCBCRSUBSAMPLING 39 +#define FIELD_YCBCRPOSITIONING 40 +#define FIELD_REFBLACKWHITE 41 +#define FIELD_TRANSFERFUNCTION 44 +#define FIELD_INKNAMES 46 +#define FIELD_SUBIFD 49 +/* FIELD_CUSTOM (see tiffio.h) 65 */ /* end of support for well-known tags; codec-private tags follow */ -#define FIELD_CODEC 66 /* base of codec-private tags */ +#define FIELD_CODEC 66 /* base of codec-private tags */ /* - * Pseudo-tags don't normally need field bits since they - * are not written to an output file (by definition). - * The library also has express logic to always query a - * codec for a pseudo-tag so allocating a field bit for - * one is a waste. If codec wants to promote the notion - * of a pseudo-tag being ``set'' or ``unset'' then it can - * do using internal state flags without polluting the - * field bit space defined for real tags. + * Pseudo-tags don't normally need field bits since they are not written to an + * output file (by definition). The library also has express logic to always + * query a codec for a pseudo-tag so allocating a field bit for one is a + * waste. If codec wants to promote the notion of a pseudo-tag being ``set'' + * or ``unset'' then it can do using internal state flags without polluting + * the field bit space defined for real tags. */ -#define FIELD_PSEUDO 0 - -#define FIELD_LAST (32*FIELD_SETLONGS-1) +#define FIELD_PSEUDO 0 -#define TIFFExtractData(tif, type, v) \ - ((uint32) ((tif)->tif_header.tiff_magic == TIFF_BIGENDIAN ? \ - ((v) >> (tif)->tif_typeshift[type]) & (tif)->tif_typemask[type] : \ - (v) & (tif)->tif_typemask[type])) -#define TIFFInsertData(tif, type, v) \ - ((uint32) ((tif)->tif_header.tiff_magic == TIFF_BIGENDIAN ? \ - ((v) & (tif)->tif_typemask[type]) << (tif)->tif_typeshift[type] : \ - (v) & (tif)->tif_typemask[type])) +#define FIELD_LAST (32*FIELD_SETLONGS-1) - -#define BITn(n) (((unsigned long)1L)<<((n)&0x1f)) -#define BITFIELDn(tif, n) ((tif)->tif_dir.td_fieldsset[(n)/32]) -#define TIFFFieldSet(tif, field) (BITFIELDn(tif, field) & BITn(field)) +#define BITn(n) (((unsigned long)1L)<<((n)&0x1f)) +#define BITFIELDn(tif, n) ((tif)->tif_dir.td_fieldsset[(n)/32]) +#define TIFFFieldSet(tif, field) (BITFIELDn(tif, field) & BITn(field)) #define TIFFSetFieldBit(tif, field) (BITFIELDn(tif, field) |= BITn(field)) #define TIFFClrFieldBit(tif, field) (BITFIELDn(tif, field) &= ~BITn(field)) -#define FieldSet(fields, f) (fields[(f)/32] & BITn(f)) -#define ResetFieldBit(fields, f) (fields[(f)/32] &= ~BITn(f)) +#define FieldSet(fields, f) (fields[(f)/32] & BITn(f)) +#define ResetFieldBit(fields, f) (fields[(f)/32] &= ~BITn(f)) + +typedef enum { + TIFF_SETGET_UNDEFINED = 0, + TIFF_SETGET_ASCII = 1, + TIFF_SETGET_UINT8 = 2, + TIFF_SETGET_SINT8 = 3, + TIFF_SETGET_UINT16 = 4, + TIFF_SETGET_SINT16 = 5, + TIFF_SETGET_UINT32 = 6, + TIFF_SETGET_SINT32 = 7, + TIFF_SETGET_UINT64 = 8, + TIFF_SETGET_SINT64 = 9, + TIFF_SETGET_FLOAT = 10, + TIFF_SETGET_DOUBLE = 11, + TIFF_SETGET_IFD8 = 12, + TIFF_SETGET_INT = 13, + TIFF_SETGET_UINT16_PAIR = 14, + TIFF_SETGET_C0_ASCII = 15, + TIFF_SETGET_C0_UINT8 = 16, + TIFF_SETGET_C0_SINT8 = 17, + TIFF_SETGET_C0_UINT16 = 18, + TIFF_SETGET_C0_SINT16 = 19, + TIFF_SETGET_C0_UINT32 = 20, + TIFF_SETGET_C0_SINT32 = 21, + TIFF_SETGET_C0_UINT64 = 22, + TIFF_SETGET_C0_SINT64 = 23, + TIFF_SETGET_C0_FLOAT = 24, + TIFF_SETGET_C0_DOUBLE = 25, + TIFF_SETGET_C0_IFD8 = 26, + TIFF_SETGET_C16_ASCII = 27, + TIFF_SETGET_C16_UINT8 = 28, + TIFF_SETGET_C16_SINT8 = 29, + TIFF_SETGET_C16_UINT16 = 30, + TIFF_SETGET_C16_SINT16 = 31, + TIFF_SETGET_C16_UINT32 = 32, + TIFF_SETGET_C16_SINT32 = 33, + TIFF_SETGET_C16_UINT64 = 34, + TIFF_SETGET_C16_SINT64 = 35, + TIFF_SETGET_C16_FLOAT = 36, + TIFF_SETGET_C16_DOUBLE = 37, + TIFF_SETGET_C16_IFD8 = 38, + TIFF_SETGET_C32_ASCII = 39, + TIFF_SETGET_C32_UINT8 = 40, + TIFF_SETGET_C32_SINT8 = 41, + TIFF_SETGET_C32_UINT16 = 42, + TIFF_SETGET_C32_SINT16 = 43, + TIFF_SETGET_C32_UINT32 = 44, + TIFF_SETGET_C32_SINT32 = 45, + TIFF_SETGET_C32_UINT64 = 46, + TIFF_SETGET_C32_SINT64 = 47, + TIFF_SETGET_C32_FLOAT = 48, + TIFF_SETGET_C32_DOUBLE = 49, + TIFF_SETGET_C32_IFD8 = 50, + TIFF_SETGET_OTHER = 51 +} TIFFSetGetFieldType; #if defined(__cplusplus) extern "C" { #endif -extern const TIFFFieldInfo *_TIFFGetFieldInfo(size_t *); -extern const TIFFFieldInfo *_TIFFGetExifFieldInfo(size_t *); -extern void _TIFFSetupFieldInfo(TIFF*, const TIFFFieldInfo[], size_t); -extern int _TIFFMergeFieldInfo(TIFF*, const TIFFFieldInfo[], int); -extern void _TIFFPrintFieldInfo(TIFF*, FILE*); -extern TIFFDataType _TIFFSampleToTagType(TIFF*); -extern const TIFFFieldInfo* _TIFFFindOrRegisterFieldInfo( TIFF *tif, - ttag_t tag, - TIFFDataType dt ); -extern TIFFFieldInfo* _TIFFCreateAnonFieldInfo( TIFF *tif, ttag_t tag, - TIFFDataType dt ); - -#define _TIFFFindFieldInfo TIFFFindFieldInfo -#define _TIFFFindFieldInfoByName TIFFFindFieldInfoByName -#define _TIFFFieldWithTag TIFFFieldWithTag -#define _TIFFFieldWithName TIFFFieldWithName + +extern const TIFFFieldArray* _TIFFGetFields(void); +extern const TIFFFieldArray* _TIFFGetExifFields(void); +extern void _TIFFSetupFields(TIFF* tif, const TIFFFieldArray* infoarray); +extern void _TIFFPrintFieldInfo(TIFF*, FILE*); + +extern int _TIFFFillStriles(TIFF*); + +typedef enum { + tfiatImage, + tfiatExif, + tfiatOther +} TIFFFieldArrayType; + +struct _TIFFFieldArray { + TIFFFieldArrayType type; /* array type, will be used to determine if IFD is image and such */ + uint32 allocated_size; /* 0 if array is constant, other if modified by future definition extension support */ + uint32 count; /* number of elements in fields array */ + TIFFField* fields; /* actual field info */ +}; + +struct _TIFFField { + uint32 field_tag; /* field's tag */ + short field_readcount; /* read count/TIFF_VARIABLE/TIFF_SPP */ + short field_writecount; /* write count/TIFF_VARIABLE */ + TIFFDataType field_type; /* type of associated data */ + uint32 reserved; /* reserved for future extension */ + TIFFSetGetFieldType set_field_type; /* type to be passed to TIFFSetField */ + TIFFSetGetFieldType get_field_type; /* type to be passed to TIFFGetField */ + unsigned short field_bit; /* bit in fieldsset bit vector */ + unsigned char field_oktochange; /* if true, can change while writing */ + unsigned char field_passcount; /* if true, pass dir count on set */ + char* field_name; /* ASCII name */ + TIFFFieldArray* field_subfields; /* if field points to child ifds, child ifd field definition array */ +}; + +extern int _TIFFMergeFields(TIFF*, const TIFFField[], uint32); +extern const TIFFField* _TIFFFindOrRegisterField(TIFF *, uint32, TIFFDataType); +extern TIFFField* _TIFFCreateAnonField(TIFF *, uint32, TIFFDataType); #if defined(__cplusplus) } @@ -200,3 +298,11 @@ extern TIFFFieldInfo* _TIFFCreateAnonFieldInfo( TIFF *tif, ttag_t tag, #endif /* _TIFFDIR_ */ /* vim: set ts=8 sts=8 sw=8 noet: */ + +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_dirinfo.c b/src/3rdparty/libtiff/libtiff/tif_dirinfo.c index 99a871c..d319931 100644 --- a/src/3rdparty/libtiff/libtiff/tif_dirinfo.c +++ b/src/3rdparty/libtiff/libtiff/tif_dirinfo.c @@ -1,26 +1,26 @@ -/* $Id: tif_dirinfo.c,v 1.65.2.7 2009-09-17 18:00:28 bfriesen Exp $ */ +/* $Id: tif_dirinfo.c,v 1.117 2012-08-19 16:56:34 bfriesen Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * - * Permission to use, copy, modify, distribute, and sell this software and + * 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. - * + * + * 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 + * 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. */ @@ -31,523 +31,301 @@ */ #include "tiffiop.h" #include <stdlib.h> -#include <string.h> /* - * NB: NB: THIS ARRAY IS ASSUMED TO BE SORTED BY TAG. - * If a tag can have both LONG and SHORT types then the LONG must be - * placed before the SHORT for writing to work properly. + * NOTE: THIS ARRAY IS ASSUMED TO BE SORTED BY TAG. * * NOTE: The second field (field_readcount) and third field (field_writecount) * sometimes use the values TIFF_VARIABLE (-1), TIFF_VARIABLE2 (-3) - * and TIFFTAG_SPP (-2). The macros should be used but would throw off - * the formatting of the code, so please interprete the -1, -2 and -3 + * and TIFF_SPP (-2). The macros should be used but would throw off + * the formatting of the code, so please interprete the -1, -2 and -3 * values accordingly. */ -static const TIFFFieldInfo -tiffFieldInfo[] = { - { TIFFTAG_SUBFILETYPE, 1, 1, TIFF_LONG, FIELD_SUBFILETYPE, - 1, 0, "SubfileType" }, -/* XXX SHORT for compatibility w/ old versions of the library */ - { TIFFTAG_SUBFILETYPE, 1, 1, TIFF_SHORT, FIELD_SUBFILETYPE, - 1, 0, "SubfileType" }, - { TIFFTAG_OSUBFILETYPE, 1, 1, TIFF_SHORT, FIELD_SUBFILETYPE, - 1, 0, "OldSubfileType" }, - { TIFFTAG_IMAGEWIDTH, 1, 1, TIFF_LONG, FIELD_IMAGEDIMENSIONS, - 0, 0, "ImageWidth" }, - { TIFFTAG_IMAGEWIDTH, 1, 1, TIFF_SHORT, FIELD_IMAGEDIMENSIONS, - 0, 0, "ImageWidth" }, - { TIFFTAG_IMAGELENGTH, 1, 1, TIFF_LONG, FIELD_IMAGEDIMENSIONS, - 1, 0, "ImageLength" }, - { TIFFTAG_IMAGELENGTH, 1, 1, TIFF_SHORT, FIELD_IMAGEDIMENSIONS, - 1, 0, "ImageLength" }, - { TIFFTAG_BITSPERSAMPLE, -1,-1, TIFF_SHORT, FIELD_BITSPERSAMPLE, - 0, 0, "BitsPerSample" }, -/* XXX LONG for compatibility with some broken TIFF writers */ - { TIFFTAG_BITSPERSAMPLE, -1,-1, TIFF_LONG, FIELD_BITSPERSAMPLE, - 0, 0, "BitsPerSample" }, - { TIFFTAG_COMPRESSION, -1, 1, TIFF_SHORT, FIELD_COMPRESSION, - 0, 0, "Compression" }, -/* XXX LONG for compatibility with some broken TIFF writers */ - { TIFFTAG_COMPRESSION, -1, 1, TIFF_LONG, FIELD_COMPRESSION, - 0, 0, "Compression" }, - { TIFFTAG_PHOTOMETRIC, 1, 1, TIFF_SHORT, FIELD_PHOTOMETRIC, - 0, 0, "PhotometricInterpretation" }, -/* XXX LONG for compatibility with some broken TIFF writers */ - { TIFFTAG_PHOTOMETRIC, 1, 1, TIFF_LONG, FIELD_PHOTOMETRIC, - 0, 0, "PhotometricInterpretation" }, - { TIFFTAG_THRESHHOLDING, 1, 1, TIFF_SHORT, FIELD_THRESHHOLDING, - 1, 0, "Threshholding" }, - { TIFFTAG_CELLWIDTH, 1, 1, TIFF_SHORT, FIELD_IGNORE, - 1, 0, "CellWidth" }, - { TIFFTAG_CELLLENGTH, 1, 1, TIFF_SHORT, FIELD_IGNORE, - 1, 0, "CellLength" }, - { TIFFTAG_FILLORDER, 1, 1, TIFF_SHORT, FIELD_FILLORDER, - 0, 0, "FillOrder" }, - { TIFFTAG_DOCUMENTNAME, -1,-1, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "DocumentName" }, - { TIFFTAG_IMAGEDESCRIPTION, -1,-1, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "ImageDescription" }, - { TIFFTAG_MAKE, -1,-1, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "Make" }, - { TIFFTAG_MODEL, -1,-1, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "Model" }, - { TIFFTAG_STRIPOFFSETS, -1,-1, TIFF_LONG, FIELD_STRIPOFFSETS, - 0, 0, "StripOffsets" }, - { TIFFTAG_STRIPOFFSETS, -1,-1, TIFF_SHORT, FIELD_STRIPOFFSETS, - 0, 0, "StripOffsets" }, - { TIFFTAG_ORIENTATION, 1, 1, TIFF_SHORT, FIELD_ORIENTATION, - 0, 0, "Orientation" }, - { TIFFTAG_SAMPLESPERPIXEL, 1, 1, TIFF_SHORT, FIELD_SAMPLESPERPIXEL, - 0, 0, "SamplesPerPixel" }, - { TIFFTAG_ROWSPERSTRIP, 1, 1, TIFF_LONG, FIELD_ROWSPERSTRIP, - 0, 0, "RowsPerStrip" }, - { TIFFTAG_ROWSPERSTRIP, 1, 1, TIFF_SHORT, FIELD_ROWSPERSTRIP, - 0, 0, "RowsPerStrip" }, - { TIFFTAG_STRIPBYTECOUNTS, -1,-1, TIFF_LONG, FIELD_STRIPBYTECOUNTS, - 0, 0, "StripByteCounts" }, - { TIFFTAG_STRIPBYTECOUNTS, -1,-1, TIFF_SHORT, FIELD_STRIPBYTECOUNTS, - 0, 0, "StripByteCounts" }, - { TIFFTAG_MINSAMPLEVALUE, -2,-1, TIFF_SHORT, FIELD_MINSAMPLEVALUE, - 1, 0, "MinSampleValue" }, - { TIFFTAG_MAXSAMPLEVALUE, -2,-1, TIFF_SHORT, FIELD_MAXSAMPLEVALUE, - 1, 0, "MaxSampleValue" }, - { TIFFTAG_XRESOLUTION, 1, 1, TIFF_RATIONAL, FIELD_RESOLUTION, - 1, 0, "XResolution" }, - { TIFFTAG_YRESOLUTION, 1, 1, TIFF_RATIONAL, FIELD_RESOLUTION, - 1, 0, "YResolution" }, - { TIFFTAG_PLANARCONFIG, 1, 1, TIFF_SHORT, FIELD_PLANARCONFIG, - 0, 0, "PlanarConfiguration" }, - { TIFFTAG_PAGENAME, -1,-1, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "PageName" }, - { TIFFTAG_XPOSITION, 1, 1, TIFF_RATIONAL, FIELD_POSITION, - 1, 0, "XPosition" }, - { TIFFTAG_YPOSITION, 1, 1, TIFF_RATIONAL, FIELD_POSITION, - 1, 0, "YPosition" }, - { TIFFTAG_FREEOFFSETS, -1,-1, TIFF_LONG, FIELD_IGNORE, - 0, 0, "FreeOffsets" }, - { TIFFTAG_FREEBYTECOUNTS, -1,-1, TIFF_LONG, FIELD_IGNORE, - 0, 0, "FreeByteCounts" }, - { TIFFTAG_GRAYRESPONSEUNIT, 1, 1, TIFF_SHORT, FIELD_IGNORE, - 1, 0, "GrayResponseUnit" }, - { TIFFTAG_GRAYRESPONSECURVE,-1,-1, TIFF_SHORT, FIELD_IGNORE, - 1, 0, "GrayResponseCurve" }, - { TIFFTAG_RESOLUTIONUNIT, 1, 1, TIFF_SHORT, FIELD_RESOLUTIONUNIT, - 1, 0, "ResolutionUnit" }, - { TIFFTAG_PAGENUMBER, 2, 2, TIFF_SHORT, FIELD_PAGENUMBER, - 1, 0, "PageNumber" }, - { TIFFTAG_COLORRESPONSEUNIT, 1, 1, TIFF_SHORT, FIELD_IGNORE, - 1, 0, "ColorResponseUnit" }, - { TIFFTAG_TRANSFERFUNCTION, -1,-1, TIFF_SHORT, FIELD_TRANSFERFUNCTION, - 1, 0, "TransferFunction" }, - { TIFFTAG_SOFTWARE, -1,-1, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "Software" }, - { TIFFTAG_DATETIME, 20,20, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "DateTime" }, - { TIFFTAG_ARTIST, -1,-1, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "Artist" }, - { TIFFTAG_HOSTCOMPUTER, -1,-1, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "HostComputer" }, - { TIFFTAG_WHITEPOINT, 2, 2, TIFF_RATIONAL, FIELD_CUSTOM, - 1, 0, "WhitePoint" }, - { TIFFTAG_PRIMARYCHROMATICITIES,6,6,TIFF_RATIONAL, FIELD_CUSTOM, - 1, 0, "PrimaryChromaticities" }, - { TIFFTAG_COLORMAP, -1,-1, TIFF_SHORT, FIELD_COLORMAP, - 1, 0, "ColorMap" }, - { TIFFTAG_HALFTONEHINTS, 2, 2, TIFF_SHORT, FIELD_HALFTONEHINTS, - 1, 0, "HalftoneHints" }, - { TIFFTAG_TILEWIDTH, 1, 1, TIFF_LONG, FIELD_TILEDIMENSIONS, - 0, 0, "TileWidth" }, - { TIFFTAG_TILEWIDTH, 1, 1, TIFF_SHORT, FIELD_TILEDIMENSIONS, - 0, 0, "TileWidth" }, - { TIFFTAG_TILELENGTH, 1, 1, TIFF_LONG, FIELD_TILEDIMENSIONS, - 0, 0, "TileLength" }, - { TIFFTAG_TILELENGTH, 1, 1, TIFF_SHORT, FIELD_TILEDIMENSIONS, - 0, 0, "TileLength" }, - { TIFFTAG_TILEOFFSETS, -1, 1, TIFF_LONG, FIELD_STRIPOFFSETS, - 0, 0, "TileOffsets" }, - { TIFFTAG_TILEBYTECOUNTS, -1, 1, TIFF_LONG, FIELD_STRIPBYTECOUNTS, - 0, 0, "TileByteCounts" }, - { TIFFTAG_TILEBYTECOUNTS, -1, 1, TIFF_SHORT, FIELD_STRIPBYTECOUNTS, - 0, 0, "TileByteCounts" }, - { TIFFTAG_SUBIFD, -1,-1, TIFF_IFD, FIELD_SUBIFD, - 1, 1, "SubIFD" }, - { TIFFTAG_SUBIFD, -1,-1, TIFF_LONG, FIELD_SUBIFD, - 1, 1, "SubIFD" }, - { TIFFTAG_INKSET, 1, 1, TIFF_SHORT, FIELD_CUSTOM, - 0, 0, "InkSet" }, - { TIFFTAG_INKNAMES, -1,-1, TIFF_ASCII, FIELD_INKNAMES, - 1, 1, "InkNames" }, - { TIFFTAG_NUMBEROFINKS, 1, 1, TIFF_SHORT, FIELD_CUSTOM, - 1, 0, "NumberOfInks" }, - { TIFFTAG_DOTRANGE, 2, 2, TIFF_SHORT, FIELD_CUSTOM, - 0, 0, "DotRange" }, - { TIFFTAG_DOTRANGE, 2, 2, TIFF_BYTE, FIELD_CUSTOM, - 0, 0, "DotRange" }, - { TIFFTAG_TARGETPRINTER, -1,-1, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "TargetPrinter" }, - { TIFFTAG_EXTRASAMPLES, -1,-1, TIFF_SHORT, FIELD_EXTRASAMPLES, - 0, 1, "ExtraSamples" }, -/* XXX for bogus Adobe Photoshop v2.5 files */ - { TIFFTAG_EXTRASAMPLES, -1,-1, TIFF_BYTE, FIELD_EXTRASAMPLES, - 0, 1, "ExtraSamples" }, - { TIFFTAG_SAMPLEFORMAT, -1,-1, TIFF_SHORT, FIELD_SAMPLEFORMAT, - 0, 0, "SampleFormat" }, - { TIFFTAG_SMINSAMPLEVALUE, -2,-1, TIFF_ANY, FIELD_SMINSAMPLEVALUE, - 1, 0, "SMinSampleValue" }, - { TIFFTAG_SMAXSAMPLEVALUE, -2,-1, TIFF_ANY, FIELD_SMAXSAMPLEVALUE, - 1, 0, "SMaxSampleValue" }, - { TIFFTAG_CLIPPATH, -1, -3, TIFF_BYTE, FIELD_CUSTOM, - 0, 1, "ClipPath" }, - { TIFFTAG_XCLIPPATHUNITS, 1, 1, TIFF_SLONG, FIELD_CUSTOM, - 0, 0, "XClipPathUnits" }, - { TIFFTAG_XCLIPPATHUNITS, 1, 1, TIFF_SSHORT, FIELD_CUSTOM, - 0, 0, "XClipPathUnits" }, - { TIFFTAG_XCLIPPATHUNITS, 1, 1, TIFF_SBYTE, FIELD_CUSTOM, - 0, 0, "XClipPathUnits" }, - { TIFFTAG_YCLIPPATHUNITS, 1, 1, TIFF_SLONG, FIELD_CUSTOM, - 0, 0, "YClipPathUnits" }, - { TIFFTAG_YCLIPPATHUNITS, 1, 1, TIFF_SSHORT, FIELD_CUSTOM, - 0, 0, "YClipPathUnits" }, - { TIFFTAG_YCLIPPATHUNITS, 1, 1, TIFF_SBYTE, FIELD_CUSTOM, - 0, 0, "YClipPathUnits" }, - { TIFFTAG_YCBCRCOEFFICIENTS, 3, 3, TIFF_RATIONAL, FIELD_CUSTOM, - 0, 0, "YCbCrCoefficients" }, - { TIFFTAG_YCBCRSUBSAMPLING, 2, 2, TIFF_SHORT, FIELD_YCBCRSUBSAMPLING, - 0, 0, "YCbCrSubsampling" }, - { TIFFTAG_YCBCRPOSITIONING, 1, 1, TIFF_SHORT, FIELD_YCBCRPOSITIONING, - 0, 0, "YCbCrPositioning" }, - { TIFFTAG_REFERENCEBLACKWHITE, 6, 6, TIFF_RATIONAL, FIELD_CUSTOM, - 1, 0, "ReferenceBlackWhite" }, -/* XXX temporarily accept LONG for backwards compatibility */ - { TIFFTAG_REFERENCEBLACKWHITE, 6, 6, TIFF_LONG, FIELD_CUSTOM, - 1, 0, "ReferenceBlackWhite" }, - { TIFFTAG_XMLPACKET, -3,-3, TIFF_BYTE, FIELD_CUSTOM, - 0, 1, "XMLPacket" }, -/* begin SGI tags */ - { TIFFTAG_MATTEING, 1, 1, TIFF_SHORT, FIELD_EXTRASAMPLES, - 0, 0, "Matteing" }, - { TIFFTAG_DATATYPE, -2,-1, TIFF_SHORT, FIELD_SAMPLEFORMAT, - 0, 0, "DataType" }, - { TIFFTAG_IMAGEDEPTH, 1, 1, TIFF_LONG, FIELD_IMAGEDEPTH, - 0, 0, "ImageDepth" }, - { TIFFTAG_IMAGEDEPTH, 1, 1, TIFF_SHORT, FIELD_IMAGEDEPTH, - 0, 0, "ImageDepth" }, - { TIFFTAG_TILEDEPTH, 1, 1, TIFF_LONG, FIELD_TILEDEPTH, - 0, 0, "TileDepth" }, - { TIFFTAG_TILEDEPTH, 1, 1, TIFF_SHORT, FIELD_TILEDEPTH, - 0, 0, "TileDepth" }, -/* end SGI tags */ -/* begin Pixar tags */ - { TIFFTAG_PIXAR_IMAGEFULLWIDTH, 1, 1, TIFF_LONG, FIELD_CUSTOM, - 1, 0, "ImageFullWidth" }, - { TIFFTAG_PIXAR_IMAGEFULLLENGTH, 1, 1, TIFF_LONG, FIELD_CUSTOM, - 1, 0, "ImageFullLength" }, - { TIFFTAG_PIXAR_TEXTUREFORMAT, -1, -1, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "TextureFormat" }, - { TIFFTAG_PIXAR_WRAPMODES, -1, -1, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "TextureWrapModes" }, - { TIFFTAG_PIXAR_FOVCOT, 1, 1, TIFF_FLOAT, FIELD_CUSTOM, - 1, 0, "FieldOfViewCotangent" }, - { TIFFTAG_PIXAR_MATRIX_WORLDTOSCREEN, 16,16, TIFF_FLOAT, - FIELD_CUSTOM, 1, 0, "MatrixWorldToScreen" }, - { TIFFTAG_PIXAR_MATRIX_WORLDTOCAMERA, 16,16, TIFF_FLOAT, - FIELD_CUSTOM, 1, 0, "MatrixWorldToCamera" }, - { TIFFTAG_COPYRIGHT, -1, -1, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "Copyright" }, -/* end Pixar tags */ - { TIFFTAG_RICHTIFFIPTC, -3, -3, TIFF_LONG, FIELD_CUSTOM, - 0, 1, "RichTIFFIPTC" }, - { TIFFTAG_PHOTOSHOP, -3, -3, TIFF_BYTE, FIELD_CUSTOM, - 0, 1, "Photoshop" }, - { TIFFTAG_EXIFIFD, 1, 1, TIFF_LONG, FIELD_CUSTOM, - 0, 0, "EXIFIFDOffset" }, - { TIFFTAG_ICCPROFILE, -3, -3, TIFF_UNDEFINED, FIELD_CUSTOM, - 0, 1, "ICC Profile" }, - { TIFFTAG_GPSIFD, 1, 1, TIFF_LONG, FIELD_CUSTOM, - 0, 0, "GPSIFDOffset" }, - { TIFFTAG_STONITS, 1, 1, TIFF_DOUBLE, FIELD_CUSTOM, - 0, 0, "StoNits" }, - { TIFFTAG_INTEROPERABILITYIFD, 1, 1, TIFF_LONG, FIELD_CUSTOM, - 0, 0, "InteroperabilityIFDOffset" }, -/* begin DNG tags */ - { TIFFTAG_DNGVERSION, 4, 4, TIFF_BYTE, FIELD_CUSTOM, - 0, 0, "DNGVersion" }, - { TIFFTAG_DNGBACKWARDVERSION, 4, 4, TIFF_BYTE, FIELD_CUSTOM, - 0, 0, "DNGBackwardVersion" }, - { TIFFTAG_UNIQUECAMERAMODEL, -1, -1, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "UniqueCameraModel" }, - { TIFFTAG_LOCALIZEDCAMERAMODEL, -1, -1, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "LocalizedCameraModel" }, - { TIFFTAG_LOCALIZEDCAMERAMODEL, -1, -1, TIFF_BYTE, FIELD_CUSTOM, - 1, 1, "LocalizedCameraModel" }, - { TIFFTAG_CFAPLANECOLOR, -1, -1, TIFF_BYTE, FIELD_CUSTOM, - 0, 1, "CFAPlaneColor" }, - { TIFFTAG_CFALAYOUT, 1, 1, TIFF_SHORT, FIELD_CUSTOM, - 0, 0, "CFALayout" }, - { TIFFTAG_LINEARIZATIONTABLE, -1, -1, TIFF_SHORT, FIELD_CUSTOM, - 0, 1, "LinearizationTable" }, - { TIFFTAG_BLACKLEVELREPEATDIM, 2, 2, TIFF_SHORT, FIELD_CUSTOM, - 0, 0, "BlackLevelRepeatDim" }, - { TIFFTAG_BLACKLEVEL, -1, -1, TIFF_LONG, FIELD_CUSTOM, - 0, 1, "BlackLevel" }, - { TIFFTAG_BLACKLEVEL, -1, -1, TIFF_SHORT, FIELD_CUSTOM, - 0, 1, "BlackLevel" }, - { TIFFTAG_BLACKLEVEL, -1, -1, TIFF_RATIONAL, FIELD_CUSTOM, - 0, 1, "BlackLevel" }, - { TIFFTAG_BLACKLEVELDELTAH, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM, - 0, 1, "BlackLevelDeltaH" }, - { TIFFTAG_BLACKLEVELDELTAV, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM, - 0, 1, "BlackLevelDeltaV" }, - { TIFFTAG_WHITELEVEL, -2, -2, TIFF_LONG, FIELD_CUSTOM, - 0, 0, "WhiteLevel" }, - { TIFFTAG_WHITELEVEL, -2, -2, TIFF_SHORT, FIELD_CUSTOM, - 0, 0, "WhiteLevel" }, - { TIFFTAG_DEFAULTSCALE, 2, 2, TIFF_RATIONAL, FIELD_CUSTOM, - 0, 0, "DefaultScale" }, - { TIFFTAG_BESTQUALITYSCALE, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM, - 0, 0, "BestQualityScale" }, - { TIFFTAG_DEFAULTCROPORIGIN, 2, 2, TIFF_LONG, FIELD_CUSTOM, - 0, 0, "DefaultCropOrigin" }, - { TIFFTAG_DEFAULTCROPORIGIN, 2, 2, TIFF_SHORT, FIELD_CUSTOM, - 0, 0, "DefaultCropOrigin" }, - { TIFFTAG_DEFAULTCROPORIGIN, 2, 2, TIFF_RATIONAL, FIELD_CUSTOM, - 0, 0, "DefaultCropOrigin" }, - { TIFFTAG_DEFAULTCROPSIZE, 2, 2, TIFF_LONG, FIELD_CUSTOM, - 0, 0, "DefaultCropSize" }, - { TIFFTAG_DEFAULTCROPSIZE, 2, 2, TIFF_SHORT, FIELD_CUSTOM, - 0, 0, "DefaultCropSize" }, - { TIFFTAG_DEFAULTCROPSIZE, 2, 2, TIFF_RATIONAL, FIELD_CUSTOM, - 0, 0, "DefaultCropSize" }, - { TIFFTAG_COLORMATRIX1, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM, - 0, 1, "ColorMatrix1" }, - { TIFFTAG_COLORMATRIX2, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM, - 0, 1, "ColorMatrix2" }, - { TIFFTAG_CAMERACALIBRATION1, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM, - 0, 1, "CameraCalibration1" }, - { TIFFTAG_CAMERACALIBRATION2, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM, - 0, 1, "CameraCalibration2" }, - { TIFFTAG_REDUCTIONMATRIX1, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM, - 0, 1, "ReductionMatrix1" }, - { TIFFTAG_REDUCTIONMATRIX2, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM, - 0, 1, "ReductionMatrix2" }, - { TIFFTAG_ANALOGBALANCE, -1, -1, TIFF_RATIONAL, FIELD_CUSTOM, - 0, 1, "AnalogBalance" }, - { TIFFTAG_ASSHOTNEUTRAL, -1, -1, TIFF_SHORT, FIELD_CUSTOM, - 0, 1, "AsShotNeutral" }, - { TIFFTAG_ASSHOTNEUTRAL, -1, -1, TIFF_RATIONAL, FIELD_CUSTOM, - 0, 1, "AsShotNeutral" }, - { TIFFTAG_ASSHOTWHITEXY, 2, 2, TIFF_RATIONAL, FIELD_CUSTOM, - 0, 0, "AsShotWhiteXY" }, - { TIFFTAG_BASELINEEXPOSURE, 1, 1, TIFF_SRATIONAL, FIELD_CUSTOM, - 0, 0, "BaselineExposure" }, - { TIFFTAG_BASELINENOISE, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM, - 0, 0, "BaselineNoise" }, - { TIFFTAG_BASELINESHARPNESS, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM, - 0, 0, "BaselineSharpness" }, - { TIFFTAG_BAYERGREENSPLIT, 1, 1, TIFF_LONG, FIELD_CUSTOM, - 0, 0, "BayerGreenSplit" }, - { TIFFTAG_LINEARRESPONSELIMIT, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM, - 0, 0, "LinearResponseLimit" }, - { TIFFTAG_CAMERASERIALNUMBER, -1, -1, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "CameraSerialNumber" }, - { TIFFTAG_LENSINFO, 4, 4, TIFF_RATIONAL, FIELD_CUSTOM, - 0, 0, "LensInfo" }, - { TIFFTAG_CHROMABLURRADIUS, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM, - 0, 0, "ChromaBlurRadius" }, - { TIFFTAG_ANTIALIASSTRENGTH, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM, - 0, 0, "AntiAliasStrength" }, - { TIFFTAG_SHADOWSCALE, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM, - 0, 0, "ShadowScale" }, - { TIFFTAG_DNGPRIVATEDATA, -1, -1, TIFF_BYTE, FIELD_CUSTOM, - 0, 1, "DNGPrivateData" }, - { TIFFTAG_MAKERNOTESAFETY, 1, 1, TIFF_SHORT, FIELD_CUSTOM, - 0, 0, "MakerNoteSafety" }, - { TIFFTAG_CALIBRATIONILLUMINANT1, 1, 1, TIFF_SHORT, FIELD_CUSTOM, - 0, 0, "CalibrationIlluminant1" }, - { TIFFTAG_CALIBRATIONILLUMINANT2, 1, 1, TIFF_SHORT, FIELD_CUSTOM, - 0, 0, "CalibrationIlluminant2" }, - { TIFFTAG_RAWDATAUNIQUEID, 16, 16, TIFF_BYTE, FIELD_CUSTOM, - 0, 0, "RawDataUniqueID" }, - { TIFFTAG_ORIGINALRAWFILENAME, -1, -1, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "OriginalRawFileName" }, - { TIFFTAG_ORIGINALRAWFILENAME, -1, -1, TIFF_BYTE, FIELD_CUSTOM, - 1, 1, "OriginalRawFileName" }, - { TIFFTAG_ORIGINALRAWFILEDATA, -1, -1, TIFF_UNDEFINED, FIELD_CUSTOM, - 0, 1, "OriginalRawFileData" }, - { TIFFTAG_ACTIVEAREA, 4, 4, TIFF_LONG, FIELD_CUSTOM, - 0, 0, "ActiveArea" }, - { TIFFTAG_ACTIVEAREA, 4, 4, TIFF_SHORT, FIELD_CUSTOM, - 0, 0, "ActiveArea" }, - { TIFFTAG_MASKEDAREAS, -1, -1, TIFF_LONG, FIELD_CUSTOM, - 0, 1, "MaskedAreas" }, - { TIFFTAG_ASSHOTICCPROFILE, -1, -1, TIFF_UNDEFINED, FIELD_CUSTOM, - 0, 1, "AsShotICCProfile" }, - { TIFFTAG_ASSHOTPREPROFILEMATRIX, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM, - 0, 1, "AsShotPreProfileMatrix" }, - { TIFFTAG_CURRENTICCPROFILE, -1, -1, TIFF_UNDEFINED, FIELD_CUSTOM, - 0, 1, "CurrentICCProfile" }, - { TIFFTAG_CURRENTPREPROFILEMATRIX, -1, -1, TIFF_SRATIONAL, FIELD_CUSTOM, - 0, 1, "CurrentPreProfileMatrix" }, -/* end DNG tags */ + +static TIFFFieldArray tiffFieldArray; +static TIFFFieldArray exifFieldArray; + +static TIFFField +tiffFields[] = { + { TIFFTAG_SUBFILETYPE, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_SUBFILETYPE, 1, 0, "SubfileType", NULL }, + { TIFFTAG_OSUBFILETYPE, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_SUBFILETYPE, 1, 0, "OldSubfileType", NULL }, + { TIFFTAG_IMAGEWIDTH, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_IMAGEDIMENSIONS, 0, 0, "ImageWidth", NULL }, + { TIFFTAG_IMAGELENGTH, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_IMAGEDIMENSIONS, 1, 0, "ImageLength", NULL }, + { TIFFTAG_BITSPERSAMPLE, -1, -1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_BITSPERSAMPLE, 0, 0, "BitsPerSample", NULL }, + { TIFFTAG_COMPRESSION, -1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_COMPRESSION, 0, 0, "Compression", NULL }, + { TIFFTAG_PHOTOMETRIC, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_PHOTOMETRIC, 0, 0, "PhotometricInterpretation", NULL }, + { TIFFTAG_THRESHHOLDING, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_THRESHHOLDING, 1, 0, "Threshholding", NULL }, + { TIFFTAG_CELLWIDTH, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_IGNORE, 1, 0, "CellWidth", NULL }, + { TIFFTAG_CELLLENGTH, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_IGNORE, 1, 0, "CellLength", NULL }, + { TIFFTAG_FILLORDER, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_FILLORDER, 0, 0, "FillOrder", NULL }, + { TIFFTAG_DOCUMENTNAME, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "DocumentName", NULL }, + { TIFFTAG_IMAGEDESCRIPTION, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ImageDescription", NULL }, + { TIFFTAG_MAKE, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "Make", NULL }, + { TIFFTAG_MODEL, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "Model", NULL }, + { TIFFTAG_STRIPOFFSETS, -1, -1, TIFF_LONG8, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_STRIPOFFSETS, 0, 0, "StripOffsets", NULL }, + { TIFFTAG_ORIENTATION, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_ORIENTATION, 0, 0, "Orientation", NULL }, + { TIFFTAG_SAMPLESPERPIXEL, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_SAMPLESPERPIXEL, 0, 0, "SamplesPerPixel", NULL }, + { TIFFTAG_ROWSPERSTRIP, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_ROWSPERSTRIP, 0, 0, "RowsPerStrip", NULL }, + { TIFFTAG_STRIPBYTECOUNTS, -1, -1, TIFF_LONG8, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_STRIPBYTECOUNTS, 0, 0, "StripByteCounts", NULL }, + { TIFFTAG_MINSAMPLEVALUE, -2, -1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_MINSAMPLEVALUE, 1, 0, "MinSampleValue", NULL }, + { TIFFTAG_MAXSAMPLEVALUE, -2, -1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_MAXSAMPLEVALUE, 1, 0, "MaxSampleValue", NULL }, + { TIFFTAG_XRESOLUTION, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_RESOLUTION, 1, 0, "XResolution", NULL }, + { TIFFTAG_YRESOLUTION, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_RESOLUTION, 1, 0, "YResolution", NULL }, + { TIFFTAG_PLANARCONFIG, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_PLANARCONFIG, 0, 0, "PlanarConfiguration", NULL }, + { TIFFTAG_PAGENAME, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "PageName", NULL }, + { TIFFTAG_XPOSITION, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_POSITION, 1, 0, "XPosition", NULL }, + { TIFFTAG_YPOSITION, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_POSITION, 1, 0, "YPosition", NULL }, + { TIFFTAG_FREEOFFSETS, -1, -1, TIFF_LONG8, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_IGNORE, 0, 0, "FreeOffsets", NULL }, + { TIFFTAG_FREEBYTECOUNTS, -1, -1, TIFF_LONG8, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_IGNORE, 0, 0, "FreeByteCounts", NULL }, + { TIFFTAG_GRAYRESPONSEUNIT, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_IGNORE, 1, 0, "GrayResponseUnit", NULL }, + { TIFFTAG_GRAYRESPONSECURVE, -1, -1, TIFF_SHORT, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_IGNORE, 1, 0, "GrayResponseCurve", NULL }, + { TIFFTAG_RESOLUTIONUNIT, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_RESOLUTIONUNIT, 1, 0, "ResolutionUnit", NULL }, + { TIFFTAG_PAGENUMBER, 2, 2, TIFF_SHORT, 0, TIFF_SETGET_UINT16_PAIR, TIFF_SETGET_UNDEFINED, FIELD_PAGENUMBER, 1, 0, "PageNumber", NULL }, + { TIFFTAG_COLORRESPONSEUNIT, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_IGNORE, 1, 0, "ColorResponseUnit", NULL }, + { TIFFTAG_TRANSFERFUNCTION, -1, -1, TIFF_SHORT, 0, TIFF_SETGET_OTHER, TIFF_SETGET_UNDEFINED, FIELD_TRANSFERFUNCTION, 1, 0, "TransferFunction", NULL }, + { TIFFTAG_SOFTWARE, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "Software", NULL }, + { TIFFTAG_DATETIME, 20, 20, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "DateTime", NULL }, + { TIFFTAG_ARTIST, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "Artist", NULL }, + { TIFFTAG_HOSTCOMPUTER, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "HostComputer", NULL }, + { TIFFTAG_WHITEPOINT, 2, 2, TIFF_RATIONAL, 0, TIFF_SETGET_C0_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "WhitePoint", NULL }, + { TIFFTAG_PRIMARYCHROMATICITIES, 6, 6, TIFF_RATIONAL, 0, TIFF_SETGET_C0_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "PrimaryChromaticities", NULL }, + { TIFFTAG_COLORMAP, -1, -1, TIFF_SHORT, 0, TIFF_SETGET_OTHER, TIFF_SETGET_UNDEFINED, FIELD_COLORMAP, 1, 0, "ColorMap", NULL }, + { TIFFTAG_HALFTONEHINTS, 2, 2, TIFF_SHORT, 0, TIFF_SETGET_UINT16_PAIR, TIFF_SETGET_UNDEFINED, FIELD_HALFTONEHINTS, 1, 0, "HalftoneHints", NULL }, + { TIFFTAG_TILEWIDTH, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_TILEDIMENSIONS, 0, 0, "TileWidth", NULL }, + { TIFFTAG_TILELENGTH, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_TILEDIMENSIONS, 0, 0, "TileLength", NULL }, + { TIFFTAG_TILEOFFSETS, -1, 1, TIFF_LONG8, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_STRIPOFFSETS, 0, 0, "TileOffsets", NULL }, + { TIFFTAG_TILEBYTECOUNTS, -1, 1, TIFF_LONG8, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_STRIPBYTECOUNTS, 0, 0, "TileByteCounts", NULL }, + { TIFFTAG_SUBIFD, -1, -1, TIFF_IFD8, 0, TIFF_SETGET_C16_IFD8, TIFF_SETGET_UNDEFINED, FIELD_SUBIFD, 1, 1, "SubIFD", &tiffFieldArray }, + { TIFFTAG_INKSET, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "InkSet", NULL }, + { TIFFTAG_INKNAMES, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_C16_ASCII, TIFF_SETGET_UNDEFINED, FIELD_INKNAMES, 1, 1, "InkNames", NULL }, + { TIFFTAG_NUMBEROFINKS, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "NumberOfInks", NULL }, + { TIFFTAG_DOTRANGE, 2, 2, TIFF_SHORT, 0, TIFF_SETGET_UINT16_PAIR, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "DotRange", NULL }, + { TIFFTAG_TARGETPRINTER, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "TargetPrinter", NULL }, + { TIFFTAG_EXTRASAMPLES, -1, -1, TIFF_SHORT, 0, TIFF_SETGET_C16_UINT16, TIFF_SETGET_UNDEFINED, FIELD_EXTRASAMPLES, 0, 1, "ExtraSamples", NULL }, + { TIFFTAG_SAMPLEFORMAT, -1, -1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_SAMPLEFORMAT, 0, 0, "SampleFormat", NULL }, + { TIFFTAG_SMINSAMPLEVALUE, -2, -1, TIFF_ANY, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_SMINSAMPLEVALUE, 1, 0, "SMinSampleValue", NULL }, + { TIFFTAG_SMAXSAMPLEVALUE, -2, -1, TIFF_ANY, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_SMAXSAMPLEVALUE, 1, 0, "SMaxSampleValue", NULL }, + { TIFFTAG_CLIPPATH, -1, -3, TIFF_BYTE, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "ClipPath", NULL }, + { TIFFTAG_XCLIPPATHUNITS, 1, 1, TIFF_SLONG, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "XClipPathUnits", NULL }, + { TIFFTAG_XCLIPPATHUNITS, 1, 1, TIFF_SBYTE, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "XClipPathUnits", NULL }, + { TIFFTAG_YCLIPPATHUNITS, 1, 1, TIFF_SLONG, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "YClipPathUnits", NULL }, + { TIFFTAG_YCBCRCOEFFICIENTS, 3, 3, TIFF_RATIONAL, 0, TIFF_SETGET_C0_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "YCbCrCoefficients", NULL }, + { TIFFTAG_YCBCRSUBSAMPLING, 2, 2, TIFF_SHORT, 0, TIFF_SETGET_UINT16_PAIR, TIFF_SETGET_UNDEFINED, FIELD_YCBCRSUBSAMPLING, 0, 0, "YCbCrSubsampling", NULL }, + { TIFFTAG_YCBCRPOSITIONING, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_YCBCRPOSITIONING, 0, 0, "YCbCrPositioning", NULL }, + { TIFFTAG_REFERENCEBLACKWHITE, 6, 6, TIFF_RATIONAL, 0, TIFF_SETGET_C0_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_REFBLACKWHITE, 1, 0, "ReferenceBlackWhite", NULL }, + { TIFFTAG_XMLPACKET, -3, -3, TIFF_BYTE, 0, TIFF_SETGET_C32_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "XMLPacket", NULL }, + /* begin SGI tags */ + { TIFFTAG_MATTEING, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_EXTRASAMPLES, 0, 0, "Matteing", NULL }, + { TIFFTAG_DATATYPE, -2, -1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_SAMPLEFORMAT, 0, 0, "DataType", NULL }, + { TIFFTAG_IMAGEDEPTH, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_IMAGEDEPTH, 0, 0, "ImageDepth", NULL }, + { TIFFTAG_TILEDEPTH, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_TILEDEPTH, 0, 0, "TileDepth", NULL }, + /* end SGI tags */ + /* begin Pixar tags */ + { TIFFTAG_PIXAR_IMAGEFULLWIDTH, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ImageFullWidth", NULL }, + { TIFFTAG_PIXAR_IMAGEFULLLENGTH, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ImageFullLength", NULL }, + { TIFFTAG_PIXAR_TEXTUREFORMAT, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "TextureFormat", NULL }, + { TIFFTAG_PIXAR_WRAPMODES, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "TextureWrapModes", NULL }, + { TIFFTAG_PIXAR_FOVCOT, 1, 1, TIFF_FLOAT, 0, TIFF_SETGET_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "FieldOfViewCotangent", NULL }, + { TIFFTAG_PIXAR_MATRIX_WORLDTOSCREEN, 16, 16, TIFF_FLOAT, 0, TIFF_SETGET_C0_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "MatrixWorldToScreen", NULL }, + { TIFFTAG_PIXAR_MATRIX_WORLDTOCAMERA, 16, 16, TIFF_FLOAT, 0, TIFF_SETGET_C0_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "MatrixWorldToCamera", NULL }, + { TIFFTAG_COPYRIGHT, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "Copyright", NULL }, + /* end Pixar tags */ + { TIFFTAG_RICHTIFFIPTC, -3, -3, TIFF_LONG, 0, TIFF_SETGET_C32_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "RichTIFFIPTC", NULL }, + { TIFFTAG_PHOTOSHOP, -3, -3, TIFF_BYTE, 0, TIFF_SETGET_C32_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "Photoshop", NULL }, + { TIFFTAG_EXIFIFD, 1, 1, TIFF_IFD8, 0, TIFF_SETGET_IFD8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "EXIFIFDOffset", &exifFieldArray }, + { TIFFTAG_ICCPROFILE, -3, -3, TIFF_UNDEFINED, 0, TIFF_SETGET_C32_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "ICC Profile", NULL }, + { TIFFTAG_GPSIFD, 1, 1, TIFF_IFD8, 0, TIFF_SETGET_IFD8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "GPSIFDOffset", NULL }, + { TIFFTAG_FAXRECVPARAMS, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UINT32, FIELD_CUSTOM, TRUE, FALSE, "FaxRecvParams", NULL }, + { TIFFTAG_FAXSUBADDRESS, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_ASCII, FIELD_CUSTOM, TRUE, FALSE, "FaxSubAddress", NULL }, + { TIFFTAG_FAXRECVTIME, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UINT32, FIELD_CUSTOM, TRUE, FALSE, "FaxRecvTime", NULL }, + { TIFFTAG_FAXDCS, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_ASCII, FIELD_CUSTOM, TRUE, FALSE, "FaxDcs", NULL }, + { TIFFTAG_STONITS, 1, 1, TIFF_DOUBLE, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "StoNits", NULL }, + { TIFFTAG_INTEROPERABILITYIFD, 1, 1, TIFF_IFD8, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "InteroperabilityIFDOffset", NULL }, + /* begin DNG tags */ + { TIFFTAG_DNGVERSION, 4, 4, TIFF_BYTE, 0, TIFF_SETGET_C0_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "DNGVersion", NULL }, + { TIFFTAG_DNGBACKWARDVERSION, 4, 4, TIFF_BYTE, 0, TIFF_SETGET_C0_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "DNGBackwardVersion", NULL }, + { TIFFTAG_UNIQUECAMERAMODEL, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "UniqueCameraModel", NULL }, + { TIFFTAG_LOCALIZEDCAMERAMODEL, -1, -1, TIFF_BYTE, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 1, "LocalizedCameraModel", NULL }, + { TIFFTAG_CFAPLANECOLOR, -1, -1, TIFF_BYTE, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "CFAPlaneColor", NULL }, + { TIFFTAG_CFALAYOUT, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "CFALayout", NULL }, + { TIFFTAG_LINEARIZATIONTABLE, -1, -1, TIFF_SHORT, 0, TIFF_SETGET_C16_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "LinearizationTable", NULL }, + { TIFFTAG_BLACKLEVELREPEATDIM, 2, 2, TIFF_SHORT, 0, TIFF_SETGET_C0_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "BlackLevelRepeatDim", NULL }, + { TIFFTAG_BLACKLEVEL, -1, -1, TIFF_RATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "BlackLevel", NULL }, + { TIFFTAG_BLACKLEVELDELTAH, -1, -1, TIFF_SRATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "BlackLevelDeltaH", NULL }, + { TIFFTAG_BLACKLEVELDELTAV, -1, -1, TIFF_SRATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "BlackLevelDeltaV", NULL }, + { TIFFTAG_WHITELEVEL, -1, -1, TIFF_LONG, 0, TIFF_SETGET_C16_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "WhiteLevel", NULL }, + { TIFFTAG_DEFAULTSCALE, 2, 2, TIFF_RATIONAL, 0, TIFF_SETGET_C0_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "DefaultScale", NULL }, + { TIFFTAG_BESTQUALITYSCALE, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "BestQualityScale", NULL }, + { TIFFTAG_DEFAULTCROPORIGIN, 2, 2, TIFF_RATIONAL, 0, TIFF_SETGET_C0_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "DefaultCropOrigin", NULL }, + { TIFFTAG_DEFAULTCROPSIZE, 2, 2, TIFF_RATIONAL, 0, TIFF_SETGET_C0_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "DefaultCropSize", NULL }, + { TIFFTAG_COLORMATRIX1, -1, -1, TIFF_SRATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "ColorMatrix1", NULL }, + { TIFFTAG_COLORMATRIX2, -1, -1, TIFF_SRATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "ColorMatrix2", NULL }, + { TIFFTAG_CAMERACALIBRATION1, -1, -1, TIFF_SRATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "CameraCalibration1", NULL }, + { TIFFTAG_CAMERACALIBRATION2, -1, -1, TIFF_SRATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "CameraCalibration2", NULL }, + { TIFFTAG_REDUCTIONMATRIX1, -1, -1, TIFF_SRATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "ReductionMatrix1", NULL }, + { TIFFTAG_REDUCTIONMATRIX2, -1, -1, TIFF_SRATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "ReductionMatrix2", NULL }, + { TIFFTAG_ANALOGBALANCE, -1, -1, TIFF_RATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "AnalogBalance", NULL }, + { TIFFTAG_ASSHOTNEUTRAL, -1, -1, TIFF_RATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "AsShotNeutral", NULL }, + { TIFFTAG_ASSHOTWHITEXY, 2, 2, TIFF_RATIONAL, 0, TIFF_SETGET_C0_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "AsShotWhiteXY", NULL }, + { TIFFTAG_BASELINEEXPOSURE, 1, 1, TIFF_SRATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "BaselineExposure", NULL }, + { TIFFTAG_BASELINENOISE, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "BaselineNoise", NULL }, + { TIFFTAG_BASELINESHARPNESS, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "BaselineSharpness", NULL }, + { TIFFTAG_BAYERGREENSPLIT, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "BayerGreenSplit", NULL }, + { TIFFTAG_LINEARRESPONSELIMIT, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "LinearResponseLimit", NULL }, + { TIFFTAG_CAMERASERIALNUMBER, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "CameraSerialNumber", NULL }, + { TIFFTAG_LENSINFO, 4, 4, TIFF_RATIONAL, 0, TIFF_SETGET_C0_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "LensInfo", NULL }, + { TIFFTAG_CHROMABLURRADIUS, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "ChromaBlurRadius", NULL }, + { TIFFTAG_ANTIALIASSTRENGTH, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "AntiAliasStrength", NULL }, + { TIFFTAG_SHADOWSCALE, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "ShadowScale", NULL }, + { TIFFTAG_DNGPRIVATEDATA, -1, -1, TIFF_BYTE, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "DNGPrivateData", NULL }, + { TIFFTAG_MAKERNOTESAFETY, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "MakerNoteSafety", NULL }, + { TIFFTAG_CALIBRATIONILLUMINANT1, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "CalibrationIlluminant1", NULL }, + { TIFFTAG_CALIBRATIONILLUMINANT2, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "CalibrationIlluminant2", NULL }, + { TIFFTAG_RAWDATAUNIQUEID, 16, 16, TIFF_BYTE, 0, TIFF_SETGET_C0_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "RawDataUniqueID", NULL }, + { TIFFTAG_ORIGINALRAWFILENAME, -1, -1, TIFF_BYTE, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 1, "OriginalRawFileName", NULL }, + { TIFFTAG_ORIGINALRAWFILEDATA, -1, -1, TIFF_UNDEFINED, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "OriginalRawFileData", NULL }, + { TIFFTAG_ACTIVEAREA, 4, 4, TIFF_LONG, 0, TIFF_SETGET_C0_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "ActiveArea", NULL }, + { TIFFTAG_MASKEDAREAS, -1, -1, TIFF_LONG, 0, TIFF_SETGET_C16_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "MaskedAreas", NULL }, + { TIFFTAG_ASSHOTICCPROFILE, -1, -1, TIFF_UNDEFINED, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "AsShotICCProfile", NULL }, + { TIFFTAG_ASSHOTPREPROFILEMATRIX, -1, -1, TIFF_SRATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "AsShotPreProfileMatrix", NULL }, + { TIFFTAG_CURRENTICCPROFILE, -1, -1, TIFF_UNDEFINED, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "CurrentICCProfile", NULL }, + { TIFFTAG_CURRENTPREPROFILEMATRIX, -1, -1, TIFF_SRATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "CurrentPreProfileMatrix", NULL }, + { TIFFTAG_PERSAMPLE, 0, 0, TIFF_SHORT, 0, TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "PerSample", NULL}, + /* end DNG tags */ + /* begin TIFF/FX tags */ + { TIFFTAG_INDEXED, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "Indexed" }, + { TIFFTAG_GLOBALPARAMETERSIFD, 1, 1, TIFF_IFD, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "GlobalParametersIFD", NULL }, + { TIFFTAG_PROFILETYPE, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "ProfileType", NULL }, + { TIFFTAG_FAXPROFILE, 1, 1, TIFF_BYTE, 0, TIFF_SETGET_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "FaxProfile", NULL }, + { TIFFTAG_CODINGMETHODS, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "CodingMethods", NULL }, + { TIFFTAG_VERSIONYEAR, 4, 4, TIFF_BYTE, 0, TIFF_SETGET_C0_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "VersionYear", NULL }, + { TIFFTAG_MODENUMBER, 1, 1, TIFF_BYTE, 0, TIFF_SETGET_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "ModeNumber", NULL }, + { TIFFTAG_DECODE, -1, -1, TIFF_SRATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "Decode", NULL }, + { TIFFTAG_IMAGEBASECOLOR, -1, -1, TIFF_SHORT, 0, TIFF_SETGET_C16_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "ImageBaseColor", NULL }, + { TIFFTAG_T82OPTIONS, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "T82Options", NULL }, + { TIFFTAG_STRIPROWCOUNTS, -1, -1, TIFF_LONG, 0, TIFF_SETGET_C16_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 1, "StripRowCounts", NULL }, + { TIFFTAG_IMAGELAYER, 2, 2, TIFF_LONG, 0, TIFF_SETGET_C0_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, "ImageLayer", NULL }, + /* end DNG tags */ + /* begin pseudo tags */ }; -static const TIFFFieldInfo -exifFieldInfo[] = { - { EXIFTAG_EXPOSURETIME, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM, - 1, 0, "ExposureTime" }, - { EXIFTAG_FNUMBER, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM, - 1, 0, "FNumber" }, - { EXIFTAG_EXPOSUREPROGRAM, 1, 1, TIFF_SHORT, FIELD_CUSTOM, - 1, 0, "ExposureProgram" }, - { EXIFTAG_SPECTRALSENSITIVITY, -1, -1, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "SpectralSensitivity" }, - { EXIFTAG_ISOSPEEDRATINGS, -1, -1, TIFF_SHORT, FIELD_CUSTOM, - 1, 1, "ISOSpeedRatings" }, - { EXIFTAG_OECF, -1, -1, TIFF_UNDEFINED, FIELD_CUSTOM, - 1, 1, "OptoelectricConversionFactor" }, - { EXIFTAG_EXIFVERSION, 4, 4, TIFF_UNDEFINED, FIELD_CUSTOM, - 1, 0, "ExifVersion" }, - { EXIFTAG_DATETIMEORIGINAL, 20, 20, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "DateTimeOriginal" }, - { EXIFTAG_DATETIMEDIGITIZED, 20, 20, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "DateTimeDigitized" }, - { EXIFTAG_COMPONENTSCONFIGURATION, 4, 4, TIFF_UNDEFINED, FIELD_CUSTOM, - 1, 0, "ComponentsConfiguration" }, - { EXIFTAG_COMPRESSEDBITSPERPIXEL, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM, - 1, 0, "CompressedBitsPerPixel" }, - { EXIFTAG_SHUTTERSPEEDVALUE, 1, 1, TIFF_SRATIONAL, FIELD_CUSTOM, - 1, 0, "ShutterSpeedValue" }, - { EXIFTAG_APERTUREVALUE, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM, - 1, 0, "ApertureValue" }, - { EXIFTAG_BRIGHTNESSVALUE, 1, 1, TIFF_SRATIONAL, FIELD_CUSTOM, - 1, 0, "BrightnessValue" }, - { EXIFTAG_EXPOSUREBIASVALUE, 1, 1, TIFF_SRATIONAL, FIELD_CUSTOM, - 1, 0, "ExposureBiasValue" }, - { EXIFTAG_MAXAPERTUREVALUE, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM, - 1, 0, "MaxApertureValue" }, - { EXIFTAG_SUBJECTDISTANCE, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM, - 1, 0, "SubjectDistance" }, - { EXIFTAG_METERINGMODE, 1, 1, TIFF_SHORT, FIELD_CUSTOM, - 1, 0, "MeteringMode" }, - { EXIFTAG_LIGHTSOURCE, 1, 1, TIFF_SHORT, FIELD_CUSTOM, - 1, 0, "LightSource" }, - { EXIFTAG_FLASH, 1, 1, TIFF_SHORT, FIELD_CUSTOM, - 1, 0, "Flash" }, - { EXIFTAG_FOCALLENGTH, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM, - 1, 0, "FocalLength" }, - { EXIFTAG_SUBJECTAREA, -1, -1, TIFF_SHORT, FIELD_CUSTOM, - 1, 1, "SubjectArea" }, - { EXIFTAG_MAKERNOTE, -1, -1, TIFF_UNDEFINED, FIELD_CUSTOM, - 1, 1, "MakerNote" }, - { EXIFTAG_USERCOMMENT, -1, -1, TIFF_UNDEFINED, FIELD_CUSTOM, - 1, 1, "UserComment" }, - { EXIFTAG_SUBSECTIME, -1, -1, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "SubSecTime" }, - { EXIFTAG_SUBSECTIMEORIGINAL, -1, -1, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "SubSecTimeOriginal" }, - { EXIFTAG_SUBSECTIMEDIGITIZED,-1, -1, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "SubSecTimeDigitized" }, - { EXIFTAG_FLASHPIXVERSION, 4, 4, TIFF_UNDEFINED, FIELD_CUSTOM, - 1, 0, "FlashpixVersion" }, - { EXIFTAG_COLORSPACE, 1, 1, TIFF_SHORT, FIELD_CUSTOM, - 1, 0, "ColorSpace" }, - { EXIFTAG_PIXELXDIMENSION, 1, 1, TIFF_LONG, FIELD_CUSTOM, - 1, 0, "PixelXDimension" }, - { EXIFTAG_PIXELXDIMENSION, 1, 1, TIFF_SHORT, FIELD_CUSTOM, - 1, 0, "PixelXDimension" }, - { EXIFTAG_PIXELYDIMENSION, 1, 1, TIFF_LONG, FIELD_CUSTOM, - 1, 0, "PixelYDimension" }, - { EXIFTAG_PIXELYDIMENSION, 1, 1, TIFF_SHORT, FIELD_CUSTOM, - 1, 0, "PixelYDimension" }, - { EXIFTAG_RELATEDSOUNDFILE, 13, 13, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "RelatedSoundFile" }, - { EXIFTAG_FLASHENERGY, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM, - 1, 0, "FlashEnergy" }, - { EXIFTAG_SPATIALFREQUENCYRESPONSE, -1, -1, TIFF_UNDEFINED, FIELD_CUSTOM, - 1, 1, "SpatialFrequencyResponse" }, - { EXIFTAG_FOCALPLANEXRESOLUTION, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM, - 1, 0, "FocalPlaneXResolution" }, - { EXIFTAG_FOCALPLANEYRESOLUTION, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM, - 1, 0, "FocalPlaneYResolution" }, - { EXIFTAG_FOCALPLANERESOLUTIONUNIT, 1, 1, TIFF_SHORT, FIELD_CUSTOM, - 1, 0, "FocalPlaneResolutionUnit" }, - { EXIFTAG_SUBJECTLOCATION, 2, 2, TIFF_SHORT, FIELD_CUSTOM, - 1, 0, "SubjectLocation" }, - { EXIFTAG_EXPOSUREINDEX, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM, - 1, 0, "ExposureIndex" }, - { EXIFTAG_SENSINGMETHOD, 1, 1, TIFF_SHORT, FIELD_CUSTOM, - 1, 0, "SensingMethod" }, - { EXIFTAG_FILESOURCE, 1, 1, TIFF_UNDEFINED, FIELD_CUSTOM, - 1, 0, "FileSource" }, - { EXIFTAG_SCENETYPE, 1, 1, TIFF_UNDEFINED, FIELD_CUSTOM, - 1, 0, "SceneType" }, - { EXIFTAG_CFAPATTERN, -1, -1, TIFF_UNDEFINED, FIELD_CUSTOM, - 1, 1, "CFAPattern" }, - { EXIFTAG_CUSTOMRENDERED, 1, 1, TIFF_SHORT, FIELD_CUSTOM, - 1, 0, "CustomRendered" }, - { EXIFTAG_EXPOSUREMODE, 1, 1, TIFF_SHORT, FIELD_CUSTOM, - 1, 0, "ExposureMode" }, - { EXIFTAG_WHITEBALANCE, 1, 1, TIFF_SHORT, FIELD_CUSTOM, - 1, 0, "WhiteBalance" }, - { EXIFTAG_DIGITALZOOMRATIO, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM, - 1, 0, "DigitalZoomRatio" }, - { EXIFTAG_FOCALLENGTHIN35MMFILM, 1, 1, TIFF_SHORT, FIELD_CUSTOM, - 1, 0, "FocalLengthIn35mmFilm" }, - { EXIFTAG_SCENECAPTURETYPE, 1, 1, TIFF_SHORT, FIELD_CUSTOM, - 1, 0, "SceneCaptureType" }, - { EXIFTAG_GAINCONTROL, 1, 1, TIFF_RATIONAL, FIELD_CUSTOM, - 1, 0, "GainControl" }, - { EXIFTAG_CONTRAST, 1, 1, TIFF_SHORT, FIELD_CUSTOM, - 1, 0, "Contrast" }, - { EXIFTAG_SATURATION, 1, 1, TIFF_SHORT, FIELD_CUSTOM, - 1, 0, "Saturation" }, - { EXIFTAG_SHARPNESS, 1, 1, TIFF_SHORT, FIELD_CUSTOM, - 1, 0, "Sharpness" }, - { EXIFTAG_DEVICESETTINGDESCRIPTION, -1, -1, TIFF_UNDEFINED, FIELD_CUSTOM, - 1, 1, "DeviceSettingDescription" }, - { EXIFTAG_SUBJECTDISTANCERANGE, 1, 1, TIFF_SHORT, FIELD_CUSTOM, - 1, 0, "SubjectDistanceRange" }, - { EXIFTAG_IMAGEUNIQUEID, 33, 33, TIFF_ASCII, FIELD_CUSTOM, - 1, 0, "ImageUniqueID" } +static TIFFField +exifFields[] = { + { EXIFTAG_EXPOSURETIME, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ExposureTime", NULL }, + { EXIFTAG_FNUMBER, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "FNumber", NULL }, + { EXIFTAG_EXPOSUREPROGRAM, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ExposureProgram", NULL }, + { EXIFTAG_SPECTRALSENSITIVITY, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "SpectralSensitivity", NULL }, + { EXIFTAG_ISOSPEEDRATINGS, -1, -1, TIFF_SHORT, 0, TIFF_SETGET_C16_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 1, "ISOSpeedRatings", NULL }, + { EXIFTAG_OECF, -1, -1, TIFF_UNDEFINED, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 1, "OptoelectricConversionFactor", NULL }, + { EXIFTAG_EXIFVERSION, 4, 4, TIFF_UNDEFINED, 0, TIFF_SETGET_C0_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ExifVersion", NULL }, + { EXIFTAG_DATETIMEORIGINAL, 20, 20, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "DateTimeOriginal", NULL }, + { EXIFTAG_DATETIMEDIGITIZED, 20, 20, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "DateTimeDigitized", NULL }, + { EXIFTAG_COMPONENTSCONFIGURATION, 4, 4, TIFF_UNDEFINED, 0, TIFF_SETGET_C0_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ComponentsConfiguration", NULL }, + { EXIFTAG_COMPRESSEDBITSPERPIXEL, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "CompressedBitsPerPixel", NULL }, + { EXIFTAG_SHUTTERSPEEDVALUE, 1, 1, TIFF_SRATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ShutterSpeedValue", NULL }, + { EXIFTAG_APERTUREVALUE, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ApertureValue", NULL }, + { EXIFTAG_BRIGHTNESSVALUE, 1, 1, TIFF_SRATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "BrightnessValue", NULL }, + { EXIFTAG_EXPOSUREBIASVALUE, 1, 1, TIFF_SRATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ExposureBiasValue", NULL }, + { EXIFTAG_MAXAPERTUREVALUE, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "MaxApertureValue", NULL }, + { EXIFTAG_SUBJECTDISTANCE, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "SubjectDistance", NULL }, + { EXIFTAG_METERINGMODE, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "MeteringMode", NULL }, + { EXIFTAG_LIGHTSOURCE, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "LightSource", NULL }, + { EXIFTAG_FLASH, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "Flash", NULL }, + { EXIFTAG_FOCALLENGTH, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "FocalLength", NULL }, + { EXIFTAG_SUBJECTAREA, -1, -1, TIFF_SHORT, 0, TIFF_SETGET_C16_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 1, "SubjectArea", NULL }, + { EXIFTAG_MAKERNOTE, -1, -1, TIFF_UNDEFINED, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 1, "MakerNote", NULL }, + { EXIFTAG_USERCOMMENT, -1, -1, TIFF_UNDEFINED, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 1, "UserComment", NULL }, + { EXIFTAG_SUBSECTIME, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "SubSecTime", NULL }, + { EXIFTAG_SUBSECTIMEORIGINAL, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "SubSecTimeOriginal", NULL }, + { EXIFTAG_SUBSECTIMEDIGITIZED, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "SubSecTimeDigitized", NULL }, + { EXIFTAG_FLASHPIXVERSION, 4, 4, TIFF_UNDEFINED, 0, TIFF_SETGET_C0_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "FlashpixVersion", NULL }, + { EXIFTAG_COLORSPACE, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ColorSpace", NULL }, + { EXIFTAG_PIXELXDIMENSION, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "PixelXDimension", NULL }, + { EXIFTAG_PIXELYDIMENSION, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "PixelYDimension", NULL }, + { EXIFTAG_RELATEDSOUNDFILE, 13, 13, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "RelatedSoundFile", NULL }, + { EXIFTAG_FLASHENERGY, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "FlashEnergy", NULL }, + { EXIFTAG_SPATIALFREQUENCYRESPONSE, -1, -1, TIFF_UNDEFINED, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 1, "SpatialFrequencyResponse", NULL }, + { EXIFTAG_FOCALPLANEXRESOLUTION, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "FocalPlaneXResolution", NULL }, + { EXIFTAG_FOCALPLANEYRESOLUTION, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "FocalPlaneYResolution", NULL }, + { EXIFTAG_FOCALPLANERESOLUTIONUNIT, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "FocalPlaneResolutionUnit", NULL }, + { EXIFTAG_SUBJECTLOCATION, 2, 2, TIFF_SHORT, 0, TIFF_SETGET_C0_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "SubjectLocation", NULL }, + { EXIFTAG_EXPOSUREINDEX, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ExposureIndex", NULL }, + { EXIFTAG_SENSINGMETHOD, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "SensingMethod", NULL }, + { EXIFTAG_FILESOURCE, 1, 1, TIFF_UNDEFINED, 0, TIFF_SETGET_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "FileSource", NULL }, + { EXIFTAG_SCENETYPE, 1, 1, TIFF_UNDEFINED, 0, TIFF_SETGET_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "SceneType", NULL }, + { EXIFTAG_CFAPATTERN, -1, -1, TIFF_UNDEFINED, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 1, "CFAPattern", NULL }, + { EXIFTAG_CUSTOMRENDERED, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "CustomRendered", NULL }, + { EXIFTAG_EXPOSUREMODE, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ExposureMode", NULL }, + { EXIFTAG_WHITEBALANCE, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "WhiteBalance", NULL }, + { EXIFTAG_DIGITALZOOMRATIO, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "DigitalZoomRatio", NULL }, + { EXIFTAG_FOCALLENGTHIN35MMFILM, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "FocalLengthIn35mmFilm", NULL }, + { EXIFTAG_SCENECAPTURETYPE, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "SceneCaptureType", NULL }, + { EXIFTAG_GAINCONTROL, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "GainControl", NULL }, + { EXIFTAG_CONTRAST, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "Contrast", NULL }, + { EXIFTAG_SATURATION, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "Saturation", NULL }, + { EXIFTAG_SHARPNESS, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "Sharpness", NULL }, + { EXIFTAG_DEVICESETTINGDESCRIPTION, -1, -1, TIFF_UNDEFINED, 0, TIFF_SETGET_C16_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 1, "DeviceSettingDescription", NULL }, + { EXIFTAG_SUBJECTDISTANCERANGE, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "SubjectDistanceRange", NULL }, + { EXIFTAG_IMAGEUNIQUEID, 33, 33, TIFF_ASCII, 0, TIFF_SETGET_ASCII, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, "ImageUniqueID", NULL } }; -const TIFFFieldInfo * -_TIFFGetFieldInfo(size_t *size) +static TIFFFieldArray +tiffFieldArray = { tfiatImage, 0, TIFFArrayCount(tiffFields), tiffFields }; +static TIFFFieldArray +exifFieldArray = { tfiatExif, 0, TIFFArrayCount(exifFields), exifFields }; + +/* + * We have our own local lfind() equivelent to avoid subtle differences + * in types passed to lfind() on different systems. + */ + +static void * +td_lfind(const void *key, const void *base, size_t *nmemb, size_t size, + int(*compar)(const void *, const void *)) { - *size = TIFFArrayCount(tiffFieldInfo); - return tiffFieldInfo; + char *element, *end; + + end = (char *)base + *nmemb * size; + for (element = (char *)base; element < end; element += size) + if (!compar(key, element)) /* key found */ + return element; + + return NULL; } -const TIFFFieldInfo * -_TIFFGetExifFieldInfo(size_t *size) +const TIFFFieldArray* +_TIFFGetFields(void) { - *size = TIFFArrayCount(exifFieldInfo); - return exifFieldInfo; + return(&tiffFieldArray); +} + +const TIFFFieldArray* +_TIFFGetExifFields(void) +{ + return(&exifFieldArray); } void -_TIFFSetupFieldInfo(TIFF* tif, const TIFFFieldInfo info[], size_t n) +_TIFFSetupFields(TIFF* tif, const TIFFFieldArray* fieldarray) { - if (tif->tif_fieldinfo) { - size_t i; + if (tif->tif_fields && tif->tif_nfields > 0) { + uint32 i; - for (i = 0; i < tif->tif_nfields; i++) - { - TIFFFieldInfo *fld = tif->tif_fieldinfo[i]; - if (fld->field_bit == FIELD_CUSTOM && + for (i = 0; i < tif->tif_nfields; i++) { + TIFFField *fld = tif->tif_fields[i]; + if (fld->field_bit == FIELD_CUSTOM && strncmp("Tag ", fld->field_name, 4) == 0) { _TIFFfree(fld->field_name); _TIFFfree(fld); } - } - - _TIFFfree(tif->tif_fieldinfo); + } + + _TIFFfree(tif->tif_fields); + tif->tif_fields = NULL; tif->tif_nfields = 0; } - if (!_TIFFMergeFieldInfo(tif, info, n)) - { - TIFFErrorExt(tif->tif_clientdata, "_TIFFSetupFieldInfo", + if (!_TIFFMergeFields(tif, fieldarray->fields, fieldarray->count)) { + TIFFErrorExt(tif->tif_clientdata, "_TIFFSetupFields", "Setting up field info failed"); } } @@ -555,8 +333,8 @@ _TIFFSetupFieldInfo(TIFF* tif, const TIFFFieldInfo info[], size_t n) static int tagCompare(const void* a, const void* b) { - const TIFFFieldInfo* ta = *(const TIFFFieldInfo**) a; - const TIFFFieldInfo* tb = *(const TIFFFieldInfo**) b; + const TIFFField* ta = *(const TIFFField**) a; + const TIFFField* tb = *(const TIFFField**) b; /* NB: be careful of return values for 16-bit platforms */ if (ta->field_tag != tb->field_tag) return (int)ta->field_tag - (int)tb->field_tag; @@ -568,8 +346,8 @@ tagCompare(const void* a, const void* b) static int tagNameCompare(const void* a, const void* b) { - const TIFFFieldInfo* ta = *(const TIFFFieldInfo**) a; - const TIFFFieldInfo* tb = *(const TIFFFieldInfo**) b; + const TIFFField* ta = *(const TIFFField**) a; + const TIFFField* tb = *(const TIFFField**) b; int ret = strcmp(ta->field_name, tb->field_name); if (ret) @@ -579,57 +357,47 @@ tagNameCompare(const void* a, const void* b) 0 : ((int)tb->field_type - (int)ta->field_type); } -void -TIFFMergeFieldInfo(TIFF* tif, const TIFFFieldInfo info[], int n) -{ - if (_TIFFMergeFieldInfo(tif, info, n) < 0) - { - TIFFErrorExt(tif->tif_clientdata, "TIFFMergeFieldInfo", - "Merging block of %d fields failed", n); - } -} - int -_TIFFMergeFieldInfo(TIFF* tif, const TIFFFieldInfo info[], int n) +_TIFFMergeFields(TIFF* tif, const TIFFField info[], uint32 n) { - static const char module[] = "_TIFFMergeFieldInfo"; - static const char reason[] = "for field info array"; - TIFFFieldInfo** tp; - int i; + static const char module[] = "_TIFFMergeFields"; + static const char reason[] = "for fields array"; + /* TIFFField** tp; */ + uint32 i; tif->tif_foundfield = NULL; - if (tif->tif_nfields > 0) { - tif->tif_fieldinfo = (TIFFFieldInfo**) - _TIFFCheckRealloc(tif, tif->tif_fieldinfo, + if (tif->tif_fields && tif->tif_nfields > 0) { + tif->tif_fields = (TIFFField**) + _TIFFCheckRealloc(tif, tif->tif_fields, (tif->tif_nfields + n), - sizeof (TIFFFieldInfo*), reason); + sizeof(TIFFField *), reason); } else { - tif->tif_fieldinfo = (TIFFFieldInfo**) - _TIFFCheckMalloc(tif, n, sizeof (TIFFFieldInfo*), + tif->tif_fields = (TIFFField **) + _TIFFCheckMalloc(tif, n, sizeof(TIFFField *), reason); } - if (!tif->tif_fieldinfo) { + if (!tif->tif_fields) { TIFFErrorExt(tif->tif_clientdata, module, - "Failed to allocate field info array"); + "Failed to allocate fields array"); return 0; } - tp = tif->tif_fieldinfo + tif->tif_nfields; - for (i = 0; i < n; i++) - { - const TIFFFieldInfo *fip = - _TIFFFindFieldInfo(tif, info[i].field_tag, info[i].field_type); - - /* only add definitions that aren't already present */ - if (!fip) { - *tp++ = (TIFFFieldInfo*) (info + i); - tif->tif_nfields++; - } - } + + /* tp = tif->tif_fields + tif->tif_nfields; */ + for (i = 0; i < n; i++) { + const TIFFField *fip = + TIFFFindField(tif, info[i].field_tag, TIFF_ANY); + + /* only add definitions that aren't already present */ + if (!fip) { + tif->tif_fields[tif->tif_nfields] = (TIFFField *) (info+i); + tif->tif_nfields++; + } + } /* Sort the field info by tag number */ - qsort(tif->tif_fieldinfo, tif->tif_nfields, - sizeof (TIFFFieldInfo*), tagCompare); + qsort(tif->tif_fields, tif->tif_nfields, + sizeof(TIFFField *), tagCompare); return n; } @@ -637,11 +405,11 @@ _TIFFMergeFieldInfo(TIFF* tif, const TIFFFieldInfo info[], int n) void _TIFFPrintFieldInfo(TIFF* tif, FILE* fd) { - size_t i; + uint32 i; fprintf(fd, "%s: \n", tif->tif_name); for (i = 0; i < tif->tif_nfields; i++) { - const TIFFFieldInfo* fip = tif->tif_fieldinfo[i]; + const TIFFField* fip = tif->tif_fields[i]; fprintf(fd, "field[%2d] %5lu, %2d, %2d, %d, %2d, %5s, %5s, %s\n" , (int)i , (unsigned long) fip->field_tag @@ -663,26 +431,29 @@ TIFFDataWidth(TIFFDataType type) { switch(type) { - case 0: /* nothing */ - case 1: /* TIFF_BYTE */ - case 2: /* TIFF_ASCII */ - case 6: /* TIFF_SBYTE */ - case 7: /* TIFF_UNDEFINED */ - return 1; - case 3: /* TIFF_SHORT */ - case 8: /* TIFF_SSHORT */ - return 2; - case 4: /* TIFF_LONG */ - case 9: /* TIFF_SLONG */ - case 11: /* TIFF_FLOAT */ - case 13: /* TIFF_IFD */ - return 4; - case 5: /* TIFF_RATIONAL */ - case 10: /* TIFF_SRATIONAL */ - case 12: /* TIFF_DOUBLE */ - return 8; - default: - return 0; /* will return 0 for unknown types */ + case 0: /* nothing */ + case TIFF_BYTE: + case TIFF_ASCII: + case TIFF_SBYTE: + case TIFF_UNDEFINED: + return 1; + case TIFF_SHORT: + case TIFF_SSHORT: + return 2; + case TIFF_LONG: + case TIFF_SLONG: + case TIFF_FLOAT: + case TIFF_IFD: + return 4; + case TIFF_RATIONAL: + case TIFF_SRATIONAL: + case TIFF_DOUBLE: + case TIFF_LONG8: + case TIFF_SLONG8: + case TIFF_IFD8: + return 8; + default: + return 0; /* will return 0 for unknown types */ } } @@ -696,7 +467,8 @@ TIFFDataWidth(TIFFDataType type) int _TIFFDataSize(TIFFDataType type) { - switch (type) { + switch (type) + { case TIFF_BYTE: case TIFF_SBYTE: case TIFF_ASCII: @@ -713,153 +485,218 @@ _TIFFDataSize(TIFFDataType type) case TIFF_SRATIONAL: return 4; case TIFF_DOUBLE: + case TIFF_LONG8: + case TIFF_SLONG8: + case TIFF_IFD8: return 8; default: return 0; } } -/* - * Return nearest TIFFDataType to the sample type of an image. - */ -TIFFDataType -_TIFFSampleToTagType(TIFF* tif) +const TIFFField* +TIFFFindField(TIFF* tif, uint32 tag, TIFFDataType dt) { - uint32 bps = TIFFhowmany8(tif->tif_dir.td_bitspersample); - - switch (tif->tif_dir.td_sampleformat) { - case SAMPLEFORMAT_IEEEFP: - return (bps == 4 ? TIFF_FLOAT : TIFF_DOUBLE); - case SAMPLEFORMAT_INT: - return (bps <= 1 ? TIFF_SBYTE : - bps <= 2 ? TIFF_SSHORT : TIFF_SLONG); - case SAMPLEFORMAT_UINT: - return (bps <= 1 ? TIFF_BYTE : - bps <= 2 ? TIFF_SHORT : TIFF_LONG); - case SAMPLEFORMAT_VOID: - return (TIFF_UNDEFINED); - } - /*NOTREACHED*/ - return (TIFF_UNDEFINED); -} - -const TIFFFieldInfo* -_TIFFFindFieldInfo(TIFF* tif, ttag_t tag, TIFFDataType dt) -{ - TIFFFieldInfo key = {0, 0, 0, TIFF_NOTYPE, 0, 0, 0, 0}; - TIFFFieldInfo* pkey = &key; - const TIFFFieldInfo **ret; - + TIFFField key = {0, 0, 0, TIFF_NOTYPE, 0, 0, 0, 0, 0, 0, NULL, NULL}; + TIFFField* pkey = &key; + const TIFFField **ret; if (tif->tif_foundfield && tif->tif_foundfield->field_tag == tag && (dt == TIFF_ANY || dt == tif->tif_foundfield->field_type)) return tif->tif_foundfield; /* If we are invoked with no field information, then just return. */ - if ( !tif->tif_fieldinfo ) { + if (!tif->tif_fields) return NULL; - } /* NB: use sorted search (e.g. binary search) */ + key.field_tag = tag; - key.field_type = dt; + key.field_type = dt; - ret = (const TIFFFieldInfo **) bsearch(&pkey, - tif->tif_fieldinfo, - tif->tif_nfields, - sizeof(TIFFFieldInfo *), - tagCompare); + ret = (const TIFFField **) bsearch(&pkey, tif->tif_fields, + tif->tif_nfields, + sizeof(TIFFField *), tagCompare); return tif->tif_foundfield = (ret ? *ret : NULL); } -const TIFFFieldInfo* -_TIFFFindFieldInfoByName(TIFF* tif, const char *field_name, TIFFDataType dt) +const TIFFField* +_TIFFFindFieldByName(TIFF* tif, const char *field_name, TIFFDataType dt) { - TIFFFieldInfo key = {0, 0, 0, TIFF_NOTYPE, 0, 0, 0, 0}; - TIFFFieldInfo* pkey = &key; - const TIFFFieldInfo **ret; - + TIFFField key = {0, 0, 0, TIFF_NOTYPE, 0, 0, 0, 0, 0, 0, NULL, NULL}; + TIFFField* pkey = &key; + const TIFFField **ret; if (tif->tif_foundfield && streq(tif->tif_foundfield->field_name, field_name) && (dt == TIFF_ANY || dt == tif->tif_foundfield->field_type)) return (tif->tif_foundfield); /* If we are invoked with no field information, then just return. */ - if ( !tif->tif_fieldinfo ) { + if (!tif->tif_fields) return NULL; - } - /* NB: use sorted search (e.g. binary search) */ - key.field_name = (char *)field_name; - key.field_type = dt; - - ret = (const TIFFFieldInfo **) lfind(&pkey, - tif->tif_fieldinfo, - &tif->tif_nfields, - sizeof(TIFFFieldInfo *), - tagNameCompare); + /* NB: use linear search since list is sorted by key#, not name */ + + key.field_name = (char *)field_name; + key.field_type = dt; + + ret = (const TIFFField **) + td_lfind(&pkey, tif->tif_fields, &tif->tif_nfields, + sizeof(TIFFField *), tagNameCompare); + return tif->tif_foundfield = (ret ? *ret : NULL); } -const TIFFFieldInfo* -_TIFFFieldWithTag(TIFF* tif, ttag_t tag) +const TIFFField* +TIFFFieldWithTag(TIFF* tif, uint32 tag) { - const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY); + const TIFFField* fip = TIFFFindField(tif, tag, TIFF_ANY); if (!fip) { TIFFErrorExt(tif->tif_clientdata, "TIFFFieldWithTag", "Internal error, unknown tag 0x%x", (unsigned int) tag); - assert(fip != NULL); - /*NOTREACHED*/ } return (fip); } -const TIFFFieldInfo* -_TIFFFieldWithName(TIFF* tif, const char *field_name) +const TIFFField* +TIFFFieldWithName(TIFF* tif, const char *field_name) { - const TIFFFieldInfo* fip = - _TIFFFindFieldInfoByName(tif, field_name, TIFF_ANY); + const TIFFField* fip = + _TIFFFindFieldByName(tif, field_name, TIFF_ANY); if (!fip) { TIFFErrorExt(tif->tif_clientdata, "TIFFFieldWithName", "Internal error, unknown tag %s", field_name); - assert(fip != NULL); - /*NOTREACHED*/ } return (fip); } -const TIFFFieldInfo* -_TIFFFindOrRegisterFieldInfo( TIFF *tif, ttag_t tag, TIFFDataType dt ) +uint32 +TIFFFieldTag(const TIFFField* fip) +{ + return fip->field_tag; +} +const char * +TIFFFieldName(const TIFFField* fip) { - const TIFFFieldInfo *fld; + return fip->field_name; +} - fld = _TIFFFindFieldInfo( tif, tag, dt ); - if( fld == NULL ) - { - fld = _TIFFCreateAnonFieldInfo( tif, tag, dt ); - if (!_TIFFMergeFieldInfo(tif, fld, 1)) - return NULL; - } +TIFFDataType +TIFFFieldDataType(const TIFFField* fip) +{ + return fip->field_type; +} + +int +TIFFFieldPassCount(const TIFFField* fip) +{ + return fip->field_passcount; +} + +int +TIFFFieldReadCount(const TIFFField* fip) +{ + return fip->field_readcount; +} - return fld; +int +TIFFFieldWriteCount(const TIFFField* fip) +{ + return fip->field_writecount; } -TIFFFieldInfo* -_TIFFCreateAnonFieldInfo(TIFF *tif, ttag_t tag, TIFFDataType field_type) +const TIFFField* +_TIFFFindOrRegisterField(TIFF *tif, uint32 tag, TIFFDataType dt) + { - TIFFFieldInfo *fld; + const TIFFField *fld; + + fld = TIFFFindField(tif, tag, dt); + if (fld == NULL) { + fld = _TIFFCreateAnonField(tif, tag, dt); + if (!_TIFFMergeFields(tif, fld, 1)) + return NULL; + } + + return fld; +} + +TIFFField* +_TIFFCreateAnonField(TIFF *tif, uint32 tag, TIFFDataType field_type) +{ + TIFFField *fld; (void) tif; - fld = (TIFFFieldInfo *) _TIFFmalloc(sizeof (TIFFFieldInfo)); + fld = (TIFFField *) _TIFFmalloc(sizeof (TIFFField)); if (fld == NULL) return NULL; - _TIFFmemset( fld, 0, sizeof(TIFFFieldInfo) ); + _TIFFmemset(fld, 0, sizeof(TIFFField)); fld->field_tag = tag; fld->field_readcount = TIFF_VARIABLE2; fld->field_writecount = TIFF_VARIABLE2; fld->field_type = field_type; + fld->reserved = 0; + switch (field_type) + { + case TIFF_BYTE: + case TIFF_UNDEFINED: + fld->set_field_type = TIFF_SETGET_C32_UINT8; + fld->get_field_type = TIFF_SETGET_C32_UINT8; + break; + case TIFF_ASCII: + fld->set_field_type = TIFF_SETGET_C32_ASCII; + fld->get_field_type = TIFF_SETGET_C32_ASCII; + break; + case TIFF_SHORT: + fld->set_field_type = TIFF_SETGET_C32_UINT16; + fld->get_field_type = TIFF_SETGET_C32_UINT16; + break; + case TIFF_LONG: + fld->set_field_type = TIFF_SETGET_C32_UINT32; + fld->get_field_type = TIFF_SETGET_C32_UINT32; + break; + case TIFF_RATIONAL: + case TIFF_SRATIONAL: + case TIFF_FLOAT: + fld->set_field_type = TIFF_SETGET_C32_FLOAT; + fld->get_field_type = TIFF_SETGET_C32_FLOAT; + break; + case TIFF_SBYTE: + fld->set_field_type = TIFF_SETGET_C32_SINT8; + fld->get_field_type = TIFF_SETGET_C32_SINT8; + break; + case TIFF_SSHORT: + fld->set_field_type = TIFF_SETGET_C32_SINT16; + fld->get_field_type = TIFF_SETGET_C32_SINT16; + break; + case TIFF_SLONG: + fld->set_field_type = TIFF_SETGET_C32_SINT32; + fld->get_field_type = TIFF_SETGET_C32_SINT32; + break; + case TIFF_DOUBLE: + fld->set_field_type = TIFF_SETGET_C32_DOUBLE; + fld->get_field_type = TIFF_SETGET_C32_DOUBLE; + break; + case TIFF_IFD: + case TIFF_IFD8: + fld->set_field_type = TIFF_SETGET_C32_IFD8; + fld->get_field_type = TIFF_SETGET_C32_IFD8; + break; + case TIFF_LONG8: + fld->set_field_type = TIFF_SETGET_C32_UINT64; + fld->get_field_type = TIFF_SETGET_C32_UINT64; + break; + case TIFF_SLONG8: + fld->set_field_type = TIFF_SETGET_C32_SINT64; + fld->get_field_type = TIFF_SETGET_C32_SINT64; + break; + default: + fld->set_field_type = TIFF_SETGET_UNDEFINED; + fld->get_field_type = TIFF_SETGET_UNDEFINED; + break; + } fld->field_bit = FIELD_CUSTOM; fld->field_oktochange = TRUE; fld->field_passcount = TRUE; @@ -868,14 +705,253 @@ _TIFFCreateAnonFieldInfo(TIFF *tif, ttag_t tag, TIFFDataType field_type) _TIFFfree(fld); return NULL; } + fld->field_subfields = NULL; /* * note that this name is a special sign to TIFFClose() and - * _TIFFSetupFieldInfo() to free the field + * _TIFFSetupFields() to free the field */ sprintf(fld->field_name, "Tag %d", (int) tag); return fld; } +/**************************************************************************** + * O B S O L E T E D I N T E R F A C E S + * + * Don't use this stuff in your applications, it may be removed in the future + * libtiff versions. + ****************************************************************************/ + +static TIFFSetGetFieldType +_TIFFSetGetType(TIFFDataType type, short count, unsigned char passcount) +{ + if (type == TIFF_ASCII && count == TIFF_VARIABLE && passcount == 0) + return TIFF_SETGET_ASCII; + + else if (count == 1 && passcount == 0) { + switch (type) + { + case TIFF_BYTE: + case TIFF_UNDEFINED: + return TIFF_SETGET_UINT8; + case TIFF_ASCII: + return TIFF_SETGET_ASCII; + case TIFF_SHORT: + return TIFF_SETGET_UINT16; + case TIFF_LONG: + return TIFF_SETGET_UINT32; + case TIFF_RATIONAL: + case TIFF_SRATIONAL: + case TIFF_FLOAT: + return TIFF_SETGET_FLOAT; + case TIFF_SBYTE: + return TIFF_SETGET_SINT8; + case TIFF_SSHORT: + return TIFF_SETGET_SINT16; + case TIFF_SLONG: + return TIFF_SETGET_SINT32; + case TIFF_DOUBLE: + return TIFF_SETGET_DOUBLE; + case TIFF_IFD: + case TIFF_IFD8: + return TIFF_SETGET_IFD8; + case TIFF_LONG8: + return TIFF_SETGET_UINT64; + case TIFF_SLONG8: + return TIFF_SETGET_SINT64; + default: + return TIFF_SETGET_UNDEFINED; + } + } + + else if (count >= 1 && passcount == 0) { + switch (type) + { + case TIFF_BYTE: + case TIFF_UNDEFINED: + return TIFF_SETGET_C0_UINT8; + case TIFF_ASCII: + return TIFF_SETGET_C0_ASCII; + case TIFF_SHORT: + return TIFF_SETGET_C0_UINT16; + case TIFF_LONG: + return TIFF_SETGET_C0_UINT32; + case TIFF_RATIONAL: + case TIFF_SRATIONAL: + case TIFF_FLOAT: + return TIFF_SETGET_C0_FLOAT; + case TIFF_SBYTE: + return TIFF_SETGET_C0_SINT8; + case TIFF_SSHORT: + return TIFF_SETGET_C0_SINT16; + case TIFF_SLONG: + return TIFF_SETGET_C0_SINT32; + case TIFF_DOUBLE: + return TIFF_SETGET_C0_DOUBLE; + case TIFF_IFD: + case TIFF_IFD8: + return TIFF_SETGET_C0_IFD8; + case TIFF_LONG8: + return TIFF_SETGET_C0_UINT64; + case TIFF_SLONG8: + return TIFF_SETGET_C0_SINT64; + default: + return TIFF_SETGET_UNDEFINED; + } + } + + else if (count == TIFF_VARIABLE && passcount == 1) { + switch (type) + { + case TIFF_BYTE: + case TIFF_UNDEFINED: + return TIFF_SETGET_C16_UINT8; + case TIFF_ASCII: + return TIFF_SETGET_C16_ASCII; + case TIFF_SHORT: + return TIFF_SETGET_C16_UINT16; + case TIFF_LONG: + return TIFF_SETGET_C16_UINT32; + case TIFF_RATIONAL: + case TIFF_SRATIONAL: + case TIFF_FLOAT: + return TIFF_SETGET_C16_FLOAT; + case TIFF_SBYTE: + return TIFF_SETGET_C16_SINT8; + case TIFF_SSHORT: + return TIFF_SETGET_C16_SINT16; + case TIFF_SLONG: + return TIFF_SETGET_C16_SINT32; + case TIFF_DOUBLE: + return TIFF_SETGET_C16_DOUBLE; + case TIFF_IFD: + case TIFF_IFD8: + return TIFF_SETGET_C16_IFD8; + case TIFF_LONG8: + return TIFF_SETGET_C16_UINT64; + case TIFF_SLONG8: + return TIFF_SETGET_C16_SINT64; + default: + return TIFF_SETGET_UNDEFINED; + } + } + + else if (count == TIFF_VARIABLE2 && passcount == 1) { + switch (type) + { + case TIFF_BYTE: + case TIFF_UNDEFINED: + return TIFF_SETGET_C32_UINT8; + case TIFF_ASCII: + return TIFF_SETGET_C32_ASCII; + case TIFF_SHORT: + return TIFF_SETGET_C32_UINT16; + case TIFF_LONG: + return TIFF_SETGET_C32_UINT32; + case TIFF_RATIONAL: + case TIFF_SRATIONAL: + case TIFF_FLOAT: + return TIFF_SETGET_C32_FLOAT; + case TIFF_SBYTE: + return TIFF_SETGET_C32_SINT8; + case TIFF_SSHORT: + return TIFF_SETGET_C32_SINT16; + case TIFF_SLONG: + return TIFF_SETGET_C32_SINT32; + case TIFF_DOUBLE: + return TIFF_SETGET_C32_DOUBLE; + case TIFF_IFD: + case TIFF_IFD8: + return TIFF_SETGET_C32_IFD8; + case TIFF_LONG8: + return TIFF_SETGET_C32_UINT64; + case TIFF_SLONG8: + return TIFF_SETGET_C32_SINT64; + default: + return TIFF_SETGET_UNDEFINED; + } + } + + return TIFF_SETGET_UNDEFINED; +} + +int +TIFFMergeFieldInfo(TIFF* tif, const TIFFFieldInfo info[], uint32 n) +{ + static const char module[] = "TIFFMergeFieldInfo"; + static const char reason[] = "for fields array"; + TIFFField *tp; + size_t nfields; + uint32 i; + + if (tif->tif_nfieldscompat > 0) { + tif->tif_fieldscompat = (TIFFFieldArray *) + _TIFFCheckRealloc(tif, tif->tif_fieldscompat, + tif->tif_nfieldscompat + 1, + sizeof(TIFFFieldArray), reason); + } else { + tif->tif_fieldscompat = (TIFFFieldArray *) + _TIFFCheckMalloc(tif, 1, sizeof(TIFFFieldArray), + reason); + } + if (!tif->tif_fieldscompat) { + TIFFErrorExt(tif->tif_clientdata, module, + "Failed to allocate fields array"); + return -1; + } + nfields = tif->tif_nfieldscompat++; + + tif->tif_fieldscompat[nfields].type = tfiatOther; + tif->tif_fieldscompat[nfields].allocated_size = n; + tif->tif_fieldscompat[nfields].count = n; + tif->tif_fieldscompat[nfields].fields = + (TIFFField *)_TIFFCheckMalloc(tif, n, sizeof(TIFFField), + reason); + if (!tif->tif_fieldscompat[nfields].fields) { + TIFFErrorExt(tif->tif_clientdata, module, + "Failed to allocate fields array"); + return -1; + } + + tp = tif->tif_fieldscompat[nfields].fields; + for (i = 0; i < n; i++) { + tp->field_tag = info[i].field_tag; + tp->field_readcount = info[i].field_readcount; + tp->field_writecount = info[i].field_writecount; + tp->field_type = info[i].field_type; + tp->reserved = 0; + tp->set_field_type = + _TIFFSetGetType(info[i].field_type, + info[i].field_readcount, + info[i].field_passcount); + tp->get_field_type = + _TIFFSetGetType(info[i].field_type, + info[i].field_readcount, + info[i].field_passcount); + tp->field_bit = info[i].field_bit; + tp->field_oktochange = info[i].field_oktochange; + tp->field_passcount = info[i].field_passcount; + tp->field_name = info[i].field_name; + tp->field_subfields = NULL; + tp++; + } + + if (!_TIFFMergeFields(tif, tif->tif_fieldscompat[nfields].fields, n)) { + TIFFErrorExt(tif->tif_clientdata, module, + "Setting up field info failed"); + return -1; + } + + return 0; +} + /* vim: set ts=8 sts=8 sw=8 noet: */ + +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_dirread.c b/src/3rdparty/libtiff/libtiff/tif_dirread.c index 52d53fc..19a26e2 100644 --- a/src/3rdparty/libtiff/libtiff/tif_dirread.c +++ b/src/3rdparty/libtiff/libtiff/tif_dirread.c @@ -1,26 +1,26 @@ -/* $Id: tif_dirread.c,v 1.92.2.6 2009-10-29 20:04:32 bfriesen Exp $ */ +/* $Id: tif_dirread.c,v 1.178 2012-08-19 16:56:34 bfriesen Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * - * Permission to use, copy, modify, distribute, and sell this software and + * 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. - * + * + * 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 + * 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. */ @@ -29,42 +29,3391 @@ * * Directory Read Support Routines. */ + +/* Suggested pending improvements: + * - add a field 'ignore' to the TIFFDirEntry structure, to flag status, + * eliminating current use of the IGNORE value, and therefore eliminating + * current irrational behaviour on tags with tag id code 0 + * - add a field 'field_info' to the TIFFDirEntry structure, and set that with + * the pointer to the appropriate TIFFField structure early on in + * TIFFReadDirectory, so as to eliminate current possibly repetitive lookup. + */ + #include "tiffiop.h" -#define IGNORE 0 /* tag placeholder used below */ +#define IGNORE 0 /* tag placeholder used below */ +#define FAILED_FII ((uint32) -1) #ifdef HAVE_IEEEFP -# define TIFFCvtIEEEFloatToNative(tif, n, fp) -# define TIFFCvtIEEEDoubleToNative(tif, n, dp) +# define TIFFCvtIEEEFloatToNative(tif, n, fp) +# define TIFFCvtIEEEDoubleToNative(tif, n, dp) #else -extern void TIFFCvtIEEEFloatToNative(TIFF*, uint32, float*); -extern void TIFFCvtIEEEDoubleToNative(TIFF*, uint32, double*); +extern void TIFFCvtIEEEFloatToNative(TIFF*, uint32, float*); +extern void TIFFCvtIEEEDoubleToNative(TIFF*, uint32, double*); #endif -static TIFFDirEntry* TIFFReadDirectoryFind(TIFFDirEntry* dir, - uint16 dircount, uint16 tagid); -static int EstimateStripByteCounts(TIFF*, TIFFDirEntry*, uint16); -static void MissingRequired(TIFF*, const char*); -static int TIFFCheckDirOffset(TIFF*, toff_t); -static int CheckDirCount(TIFF*, TIFFDirEntry*, uint32); -static uint16 TIFFFetchDirectory(TIFF*, toff_t, TIFFDirEntry**, toff_t *); -static tsize_t TIFFFetchData(TIFF*, TIFFDirEntry*, char*); -static tsize_t TIFFFetchString(TIFF*, TIFFDirEntry*, char*); -static float TIFFFetchRational(TIFF*, TIFFDirEntry*); -static int TIFFFetchNormalTag(TIFF*, TIFFDirEntry*); -static int TIFFFetchPerSampleShorts(TIFF*, TIFFDirEntry*, uint16*); -static int TIFFFetchPerSampleLongs(TIFF*, TIFFDirEntry*, uint32*); -static int TIFFFetchPerSampleAnys(TIFF*, TIFFDirEntry*, double*); -static int TIFFFetchShortArray(TIFF*, TIFFDirEntry*, uint16*); -static int TIFFFetchStripThing(TIFF*, TIFFDirEntry*, long, uint32**); -static int TIFFFetchRefBlackWhite(TIFF*, TIFFDirEntry*); -static int TIFFFetchSubjectDistance(TIFF*, TIFFDirEntry*); -static float TIFFFetchFloat(TIFF*, TIFFDirEntry*); -static int TIFFFetchFloatArray(TIFF*, TIFFDirEntry*, float*); -static int TIFFFetchDoubleArray(TIFF*, TIFFDirEntry*, double*); -static int TIFFFetchAnyArray(TIFF*, TIFFDirEntry*, double*); -static int TIFFFetchShortPair(TIFF*, TIFFDirEntry*); -static void ChopUpSingleUncompressedStrip(TIFF*); +enum TIFFReadDirEntryErr { + TIFFReadDirEntryErrOk = 0, + TIFFReadDirEntryErrCount = 1, + TIFFReadDirEntryErrType = 2, + TIFFReadDirEntryErrIo = 3, + TIFFReadDirEntryErrRange = 4, + TIFFReadDirEntryErrPsdif = 5, + TIFFReadDirEntryErrSizesan = 6, + TIFFReadDirEntryErrAlloc = 7, +}; + +static enum TIFFReadDirEntryErr TIFFReadDirEntryByte(TIFF* tif, TIFFDirEntry* direntry, uint8* value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryShort(TIFF* tif, TIFFDirEntry* direntry, uint16* value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryLong(TIFF* tif, TIFFDirEntry* direntry, uint32* value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8(TIFF* tif, TIFFDirEntry* direntry, uint64* value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryFloat(TIFF* tif, TIFFDirEntry* direntry, float* value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryDouble(TIFF* tif, TIFFDirEntry* direntry, double* value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8(TIFF* tif, TIFFDirEntry* direntry, uint64* value); + +static enum TIFFReadDirEntryErr TIFFReadDirEntryArray(TIFF* tif, TIFFDirEntry* direntry, uint32* count, uint32 desttypesize, void** value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryByteArray(TIFF* tif, TIFFDirEntry* direntry, uint8** value); +static enum TIFFReadDirEntryErr TIFFReadDirEntrySbyteArray(TIFF* tif, TIFFDirEntry* direntry, int8** value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryShortArray(TIFF* tif, TIFFDirEntry* direntry, uint16** value); +static enum TIFFReadDirEntryErr TIFFReadDirEntrySshortArray(TIFF* tif, TIFFDirEntry* direntry, int16** value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryLongArray(TIFF* tif, TIFFDirEntry* direntry, uint32** value); +static enum TIFFReadDirEntryErr TIFFReadDirEntrySlongArray(TIFF* tif, TIFFDirEntry* direntry, int32** value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8Array(TIFF* tif, TIFFDirEntry* direntry, uint64** value); +static enum TIFFReadDirEntryErr TIFFReadDirEntrySlong8Array(TIFF* tif, TIFFDirEntry* direntry, int64** value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryFloatArray(TIFF* tif, TIFFDirEntry* direntry, float** value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryDoubleArray(TIFF* tif, TIFFDirEntry* direntry, double** value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8Array(TIFF* tif, TIFFDirEntry* direntry, uint64** value); + +static enum TIFFReadDirEntryErr TIFFReadDirEntryPersampleShort(TIFF* tif, TIFFDirEntry* direntry, uint16* value); +#if 0 +static enum TIFFReadDirEntryErr TIFFReadDirEntryPersampleDouble(TIFF* tif, TIFFDirEntry* direntry, double* value); +#endif + +static void TIFFReadDirEntryCheckedByte(TIFF* tif, TIFFDirEntry* direntry, uint8* value); +static void TIFFReadDirEntryCheckedSbyte(TIFF* tif, TIFFDirEntry* direntry, int8* value); +static void TIFFReadDirEntryCheckedShort(TIFF* tif, TIFFDirEntry* direntry, uint16* value); +static void TIFFReadDirEntryCheckedSshort(TIFF* tif, TIFFDirEntry* direntry, int16* value); +static void TIFFReadDirEntryCheckedLong(TIFF* tif, TIFFDirEntry* direntry, uint32* value); +static void TIFFReadDirEntryCheckedSlong(TIFF* tif, TIFFDirEntry* direntry, int32* value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedLong8(TIFF* tif, TIFFDirEntry* direntry, uint64* value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedSlong8(TIFF* tif, TIFFDirEntry* direntry, int64* value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedRational(TIFF* tif, TIFFDirEntry* direntry, double* value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedSrational(TIFF* tif, TIFFDirEntry* direntry, double* value); +static void TIFFReadDirEntryCheckedFloat(TIFF* tif, TIFFDirEntry* direntry, float* value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedDouble(TIFF* tif, TIFFDirEntry* direntry, double* value); + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSbyte(int8 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteShort(uint16 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSshort(int16 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteLong(uint32 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSlong(int32 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteLong8(uint64 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSlong8(int64 value); + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteByte(uint8 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteShort(uint16 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSshort(int16 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteLong(uint32 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSlong(int32 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteLong8(uint64 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSlong8(int64 value); + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSbyte(int8 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSshort(int16 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortLong(uint32 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSlong(int32 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortLong8(uint64 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSlong8(int64 value); + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortShort(uint16 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortLong(uint32 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortSlong(int32 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortLong8(uint64 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortSlong8(int64 value); + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSbyte(int8 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSshort(int16 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSlong(int32 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongLong8(uint64 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSlong8(int64 value); + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSlongLong(uint32 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSlongLong8(uint64 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSlongSlong8(int64 value); + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLong8Sbyte(int8 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLong8Sshort(int16 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLong8Slong(int32 value); +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLong8Slong8(int64 value); + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSlong8Long8(uint64 value); + +static enum TIFFReadDirEntryErr TIFFReadDirEntryData(TIFF* tif, uint64 offset, tmsize_t size, void* dest); +static void TIFFReadDirEntryOutputErr(TIFF* tif, enum TIFFReadDirEntryErr err, const char* module, const char* tagname, int recover); + +static void TIFFReadDirectoryCheckOrder(TIFF* tif, TIFFDirEntry* dir, uint16 dircount); +static TIFFDirEntry* TIFFReadDirectoryFindEntry(TIFF* tif, TIFFDirEntry* dir, uint16 dircount, uint16 tagid); +static void TIFFReadDirectoryFindFieldInfo(TIFF* tif, uint16 tagid, uint32* fii); + +static int EstimateStripByteCounts(TIFF* tif, TIFFDirEntry* dir, uint16 dircount); +static void MissingRequired(TIFF*, const char*); +static int TIFFCheckDirOffset(TIFF* tif, uint64 diroff); +static int CheckDirCount(TIFF*, TIFFDirEntry*, uint32); +static uint16 TIFFFetchDirectory(TIFF* tif, uint64 diroff, TIFFDirEntry** pdir, uint64* nextdiroff); +static int TIFFFetchNormalTag(TIFF*, TIFFDirEntry*, int recover); +static int TIFFFetchStripThing(TIFF* tif, TIFFDirEntry* dir, uint32 nstrips, uint64** lpp); +static int TIFFFetchSubjectDistance(TIFF*, TIFFDirEntry*); +static void ChopUpSingleUncompressedStrip(TIFF*); +static uint64 TIFFReadUInt64(const uint8 *value); + +typedef union _UInt64Aligned_t +{ + double d; + uint64 l; + uint32 i[2]; + uint16 s[4]; + uint8 c[8]; +} UInt64Aligned_t; + +/* + Unaligned safe copy of a uint64 value from an octet array. +*/ +static uint64 TIFFReadUInt64(const uint8 *value) +{ + UInt64Aligned_t result; + + result.c[0]=value[0]; + result.c[1]=value[1]; + result.c[2]=value[2]; + result.c[3]=value[3]; + result.c[4]=value[4]; + result.c[5]=value[5]; + result.c[6]=value[6]; + result.c[7]=value[7]; + + return result.l; +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryByte(TIFF* tif, TIFFDirEntry* direntry, uint8* value) +{ + enum TIFFReadDirEntryErr err; + if (direntry->tdir_count!=1) + return(TIFFReadDirEntryErrCount); + switch (direntry->tdir_type) + { + case TIFF_BYTE: + TIFFReadDirEntryCheckedByte(tif,direntry,value); + return(TIFFReadDirEntryErrOk); + case TIFF_SBYTE: + { + int8 m; + TIFFReadDirEntryCheckedSbyte(tif,direntry,&m); + err=TIFFReadDirEntryCheckRangeByteSbyte(m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(uint8)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SHORT: + { + uint16 m; + TIFFReadDirEntryCheckedShort(tif,direntry,&m); + err=TIFFReadDirEntryCheckRangeByteShort(m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(uint8)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SSHORT: + { + int16 m; + TIFFReadDirEntryCheckedSshort(tif,direntry,&m); + err=TIFFReadDirEntryCheckRangeByteSshort(m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(uint8)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_LONG: + { + uint32 m; + TIFFReadDirEntryCheckedLong(tif,direntry,&m); + err=TIFFReadDirEntryCheckRangeByteLong(m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(uint8)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SLONG: + { + int32 m; + TIFFReadDirEntryCheckedSlong(tif,direntry,&m); + err=TIFFReadDirEntryCheckRangeByteSlong(m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(uint8)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_LONG8: + { + uint64 m; + err=TIFFReadDirEntryCheckedLong8(tif,direntry,&m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + err=TIFFReadDirEntryCheckRangeByteLong8(m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(uint8)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SLONG8: + { + int64 m; + err=TIFFReadDirEntryCheckedSlong8(tif,direntry,&m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + err=TIFFReadDirEntryCheckRangeByteSlong8(m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(uint8)m; + return(TIFFReadDirEntryErrOk); + } + default: + return(TIFFReadDirEntryErrType); + } +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryShort(TIFF* tif, TIFFDirEntry* direntry, uint16* value) +{ + enum TIFFReadDirEntryErr err; + if (direntry->tdir_count!=1) + return(TIFFReadDirEntryErrCount); + switch (direntry->tdir_type) + { + case TIFF_BYTE: + { + uint8 m; + TIFFReadDirEntryCheckedByte(tif,direntry,&m); + *value=(uint16)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SBYTE: + { + int8 m; + TIFFReadDirEntryCheckedSbyte(tif,direntry,&m); + err=TIFFReadDirEntryCheckRangeShortSbyte(m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(uint16)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SHORT: + TIFFReadDirEntryCheckedShort(tif,direntry,value); + return(TIFFReadDirEntryErrOk); + case TIFF_SSHORT: + { + int16 m; + TIFFReadDirEntryCheckedSshort(tif,direntry,&m); + err=TIFFReadDirEntryCheckRangeShortSshort(m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(uint16)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_LONG: + { + uint32 m; + TIFFReadDirEntryCheckedLong(tif,direntry,&m); + err=TIFFReadDirEntryCheckRangeShortLong(m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(uint16)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SLONG: + { + int32 m; + TIFFReadDirEntryCheckedSlong(tif,direntry,&m); + err=TIFFReadDirEntryCheckRangeShortSlong(m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(uint16)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_LONG8: + { + uint64 m; + err=TIFFReadDirEntryCheckedLong8(tif,direntry,&m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + err=TIFFReadDirEntryCheckRangeShortLong8(m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(uint16)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SLONG8: + { + int64 m; + err=TIFFReadDirEntryCheckedSlong8(tif,direntry,&m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + err=TIFFReadDirEntryCheckRangeShortSlong8(m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(uint16)m; + return(TIFFReadDirEntryErrOk); + } + default: + return(TIFFReadDirEntryErrType); + } +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryLong(TIFF* tif, TIFFDirEntry* direntry, uint32* value) +{ + enum TIFFReadDirEntryErr err; + if (direntry->tdir_count!=1) + return(TIFFReadDirEntryErrCount); + switch (direntry->tdir_type) + { + case TIFF_BYTE: + { + uint8 m; + TIFFReadDirEntryCheckedByte(tif,direntry,&m); + *value=(uint32)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SBYTE: + { + int8 m; + TIFFReadDirEntryCheckedSbyte(tif,direntry,&m); + err=TIFFReadDirEntryCheckRangeLongSbyte(m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(uint32)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SHORT: + { + uint16 m; + TIFFReadDirEntryCheckedShort(tif,direntry,&m); + *value=(uint32)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SSHORT: + { + int16 m; + TIFFReadDirEntryCheckedSshort(tif,direntry,&m); + err=TIFFReadDirEntryCheckRangeLongSshort(m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(uint32)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_LONG: + TIFFReadDirEntryCheckedLong(tif,direntry,value); + return(TIFFReadDirEntryErrOk); + case TIFF_SLONG: + { + int32 m; + TIFFReadDirEntryCheckedSlong(tif,direntry,&m); + err=TIFFReadDirEntryCheckRangeLongSlong(m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(uint32)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_LONG8: + { + uint64 m; + err=TIFFReadDirEntryCheckedLong8(tif,direntry,&m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + err=TIFFReadDirEntryCheckRangeLongLong8(m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(uint32)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SLONG8: + { + int64 m; + err=TIFFReadDirEntryCheckedSlong8(tif,direntry,&m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + err=TIFFReadDirEntryCheckRangeLongSlong8(m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(uint32)m; + return(TIFFReadDirEntryErrOk); + } + default: + return(TIFFReadDirEntryErrType); + } +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8(TIFF* tif, TIFFDirEntry* direntry, uint64* value) +{ + enum TIFFReadDirEntryErr err; + if (direntry->tdir_count!=1) + return(TIFFReadDirEntryErrCount); + switch (direntry->tdir_type) + { + case TIFF_BYTE: + { + uint8 m; + TIFFReadDirEntryCheckedByte(tif,direntry,&m); + *value=(uint64)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SBYTE: + { + int8 m; + TIFFReadDirEntryCheckedSbyte(tif,direntry,&m); + err=TIFFReadDirEntryCheckRangeLong8Sbyte(m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(uint64)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SHORT: + { + uint16 m; + TIFFReadDirEntryCheckedShort(tif,direntry,&m); + *value=(uint64)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SSHORT: + { + int16 m; + TIFFReadDirEntryCheckedSshort(tif,direntry,&m); + err=TIFFReadDirEntryCheckRangeLong8Sshort(m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(uint64)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_LONG: + { + uint32 m; + TIFFReadDirEntryCheckedLong(tif,direntry,&m); + *value=(uint64)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SLONG: + { + int32 m; + TIFFReadDirEntryCheckedSlong(tif,direntry,&m); + err=TIFFReadDirEntryCheckRangeLong8Slong(m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(uint64)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_LONG8: + err=TIFFReadDirEntryCheckedLong8(tif,direntry,value); + return(err); + case TIFF_SLONG8: + { + int64 m; + err=TIFFReadDirEntryCheckedSlong8(tif,direntry,&m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + err=TIFFReadDirEntryCheckRangeLong8Slong8(m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(uint64)m; + return(TIFFReadDirEntryErrOk); + } + default: + return(TIFFReadDirEntryErrType); + } +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryFloat(TIFF* tif, TIFFDirEntry* direntry, float* value) +{ + enum TIFFReadDirEntryErr err; + if (direntry->tdir_count!=1) + return(TIFFReadDirEntryErrCount); + switch (direntry->tdir_type) + { + case TIFF_BYTE: + { + uint8 m; + TIFFReadDirEntryCheckedByte(tif,direntry,&m); + *value=(float)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SBYTE: + { + int8 m; + TIFFReadDirEntryCheckedSbyte(tif,direntry,&m); + *value=(float)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SHORT: + { + uint16 m; + TIFFReadDirEntryCheckedShort(tif,direntry,&m); + *value=(float)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SSHORT: + { + int16 m; + TIFFReadDirEntryCheckedSshort(tif,direntry,&m); + *value=(float)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_LONG: + { + uint32 m; + TIFFReadDirEntryCheckedLong(tif,direntry,&m); + *value=(float)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SLONG: + { + int32 m; + TIFFReadDirEntryCheckedSlong(tif,direntry,&m); + *value=(float)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_LONG8: + { + uint64 m; + err=TIFFReadDirEntryCheckedLong8(tif,direntry,&m); + if (err!=TIFFReadDirEntryErrOk) + return(err); +#if defined(__WIN32__) && (_MSC_VER < 1500) + /* + * XXX: MSVC 6.0 does not support conversion + * of 64-bit integers into floating point + * values. + */ + *value = _TIFFUInt64ToFloat(m); +#else + *value=(float)m; +#endif + return(TIFFReadDirEntryErrOk); + } + case TIFF_SLONG8: + { + int64 m; + err=TIFFReadDirEntryCheckedSlong8(tif,direntry,&m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(float)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_RATIONAL: + { + double m; + err=TIFFReadDirEntryCheckedRational(tif,direntry,&m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(float)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SRATIONAL: + { + double m; + err=TIFFReadDirEntryCheckedSrational(tif,direntry,&m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(float)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_FLOAT: + TIFFReadDirEntryCheckedFloat(tif,direntry,value); + return(TIFFReadDirEntryErrOk); + case TIFF_DOUBLE: + { + double m; + err=TIFFReadDirEntryCheckedDouble(tif,direntry,&m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(float)m; + return(TIFFReadDirEntryErrOk); + } + default: + return(TIFFReadDirEntryErrType); + } +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryDouble(TIFF* tif, TIFFDirEntry* direntry, double* value) +{ + enum TIFFReadDirEntryErr err; + if (direntry->tdir_count!=1) + return(TIFFReadDirEntryErrCount); + switch (direntry->tdir_type) + { + case TIFF_BYTE: + { + uint8 m; + TIFFReadDirEntryCheckedByte(tif,direntry,&m); + *value=(double)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SBYTE: + { + int8 m; + TIFFReadDirEntryCheckedSbyte(tif,direntry,&m); + *value=(double)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SHORT: + { + uint16 m; + TIFFReadDirEntryCheckedShort(tif,direntry,&m); + *value=(double)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SSHORT: + { + int16 m; + TIFFReadDirEntryCheckedSshort(tif,direntry,&m); + *value=(double)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_LONG: + { + uint32 m; + TIFFReadDirEntryCheckedLong(tif,direntry,&m); + *value=(double)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SLONG: + { + int32 m; + TIFFReadDirEntryCheckedSlong(tif,direntry,&m); + *value=(double)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_LONG8: + { + uint64 m; + err=TIFFReadDirEntryCheckedLong8(tif,direntry,&m); + if (err!=TIFFReadDirEntryErrOk) + return(err); +#if defined(__WIN32__) && (_MSC_VER < 1500) + /* + * XXX: MSVC 6.0 does not support conversion + * of 64-bit integers into floating point + * values. + */ + *value = _TIFFUInt64ToDouble(m); +#else + *value = (double)m; +#endif + return(TIFFReadDirEntryErrOk); + } + case TIFF_SLONG8: + { + int64 m; + err=TIFFReadDirEntryCheckedSlong8(tif,direntry,&m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + *value=(double)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_RATIONAL: + err=TIFFReadDirEntryCheckedRational(tif,direntry,value); + return(err); + case TIFF_SRATIONAL: + err=TIFFReadDirEntryCheckedSrational(tif,direntry,value); + return(err); + case TIFF_FLOAT: + { + float m; + TIFFReadDirEntryCheckedFloat(tif,direntry,&m); + *value=(double)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_DOUBLE: + err=TIFFReadDirEntryCheckedDouble(tif,direntry,value); + return(err); + default: + return(TIFFReadDirEntryErrType); + } +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8(TIFF* tif, TIFFDirEntry* direntry, uint64* value) +{ + enum TIFFReadDirEntryErr err; + if (direntry->tdir_count!=1) + return(TIFFReadDirEntryErrCount); + switch (direntry->tdir_type) + { + case TIFF_LONG: + case TIFF_IFD: + { + uint32 m; + TIFFReadDirEntryCheckedLong(tif,direntry,&m); + *value=(uint64)m; + return(TIFFReadDirEntryErrOk); + } + case TIFF_LONG8: + case TIFF_IFD8: + err=TIFFReadDirEntryCheckedLong8(tif,direntry,value); + return(err); + default: + return(TIFFReadDirEntryErrType); + } +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryArray(TIFF* tif, TIFFDirEntry* direntry, uint32* count, uint32 desttypesize, void** value) +{ + int typesize; + uint32 datasize; + void* data; + typesize=TIFFDataWidth(direntry->tdir_type); + if ((direntry->tdir_count==0)||(typesize==0)) + { + *value=0; + return(TIFFReadDirEntryErrOk); + } + (void) desttypesize; + + /* + * As a sanity check, make sure we have no more than a 2GB tag array + * in either the current data type or the dest data type. This also + * avoids problems with overflow of tmsize_t on 32bit systems. + */ + if ((uint64)(2147483647/typesize)<direntry->tdir_count) + return(TIFFReadDirEntryErrSizesan); + if ((uint64)(2147483647/desttypesize)<direntry->tdir_count) + return(TIFFReadDirEntryErrSizesan); + + *count=(uint32)direntry->tdir_count; + datasize=(*count)*typesize; + assert((tmsize_t)datasize>0); + data=_TIFFCheckMalloc(tif, *count, typesize, "ReadDirEntryArray"); + if (data==0) + return(TIFFReadDirEntryErrAlloc); + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + if (datasize<=4) + _TIFFmemcpy(data,&direntry->tdir_offset,datasize); + else + { + enum TIFFReadDirEntryErr err; + uint32 offset = direntry->tdir_offset.toff_long; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(&offset); + err=TIFFReadDirEntryData(tif,(uint64)offset,(tmsize_t)datasize,data); + if (err!=TIFFReadDirEntryErrOk) + { + _TIFFfree(data); + return(err); + } + } + } + else + { + if (datasize<=8) + _TIFFmemcpy(data,&direntry->tdir_offset,datasize); + else + { + enum TIFFReadDirEntryErr err; + uint64 offset = direntry->tdir_offset.toff_long8; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8(&offset); + err=TIFFReadDirEntryData(tif,offset,(tmsize_t)datasize,data); + if (err!=TIFFReadDirEntryErrOk) + { + _TIFFfree(data); + return(err); + } + } + } + *value=data; + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryByteArray(TIFF* tif, TIFFDirEntry* direntry, uint8** value) +{ + enum TIFFReadDirEntryErr err; + uint32 count; + void* origdata; + uint8* data; + switch (direntry->tdir_type) + { + case TIFF_ASCII: + case TIFF_UNDEFINED: + case TIFF_BYTE: + case TIFF_SBYTE: + case TIFF_SHORT: + case TIFF_SSHORT: + case TIFF_LONG: + case TIFF_SLONG: + case TIFF_LONG8: + case TIFF_SLONG8: + break; + default: + return(TIFFReadDirEntryErrType); + } + err=TIFFReadDirEntryArray(tif,direntry,&count,1,&origdata); + if ((err!=TIFFReadDirEntryErrOk)||(origdata==0)) + { + *value=0; + return(err); + } + switch (direntry->tdir_type) + { + case TIFF_ASCII: + case TIFF_UNDEFINED: + case TIFF_BYTE: + *value=(uint8*)origdata; + return(TIFFReadDirEntryErrOk); + case TIFF_SBYTE: + { + int8* m; + uint32 n; + m=(int8*)origdata; + for (n=0; n<count; n++) + { + err=TIFFReadDirEntryCheckRangeByteSbyte(*m); + if (err!=TIFFReadDirEntryErrOk) + { + _TIFFfree(origdata); + return(err); + } + m++; + } + *value=(uint8*)origdata; + return(TIFFReadDirEntryErrOk); + } + } + data=(uint8*)_TIFFmalloc(count); + if (data==0) + { + _TIFFfree(origdata); + return(TIFFReadDirEntryErrAlloc); + } + switch (direntry->tdir_type) + { + case TIFF_SHORT: + { + uint16* ma; + uint8* mb; + uint32 n; + ma=(uint16*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort(ma); + err=TIFFReadDirEntryCheckRangeByteShort(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(uint8)(*ma++); + } + } + break; + case TIFF_SSHORT: + { + int16* ma; + uint8* mb; + uint32 n; + ma=(int16*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort((uint16*)ma); + err=TIFFReadDirEntryCheckRangeByteSshort(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(uint8)(*ma++); + } + } + break; + case TIFF_LONG: + { + uint32* ma; + uint8* mb; + uint32 n; + ma=(uint32*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(ma); + err=TIFFReadDirEntryCheckRangeByteLong(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(uint8)(*ma++); + } + } + break; + case TIFF_SLONG: + { + int32* ma; + uint8* mb; + uint32 n; + ma=(int32*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong((uint32*)ma); + err=TIFFReadDirEntryCheckRangeByteSlong(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(uint8)(*ma++); + } + } + break; + case TIFF_LONG8: + { + uint64* ma; + uint8* mb; + uint32 n; + ma=(uint64*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8(ma); + err=TIFFReadDirEntryCheckRangeByteLong8(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(uint8)(*ma++); + } + } + break; + case TIFF_SLONG8: + { + int64* ma; + uint8* mb; + uint32 n; + ma=(int64*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8((uint64*)ma); + err=TIFFReadDirEntryCheckRangeByteSlong8(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(uint8)(*ma++); + } + } + break; + } + _TIFFfree(origdata); + if (err!=TIFFReadDirEntryErrOk) + { + _TIFFfree(data); + return(err); + } + *value=data; + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntrySbyteArray(TIFF* tif, TIFFDirEntry* direntry, int8** value) +{ + enum TIFFReadDirEntryErr err; + uint32 count; + void* origdata; + int8* data; + switch (direntry->tdir_type) + { + case TIFF_UNDEFINED: + case TIFF_BYTE: + case TIFF_SBYTE: + case TIFF_SHORT: + case TIFF_SSHORT: + case TIFF_LONG: + case TIFF_SLONG: + case TIFF_LONG8: + case TIFF_SLONG8: + break; + default: + return(TIFFReadDirEntryErrType); + } + err=TIFFReadDirEntryArray(tif,direntry,&count,1,&origdata); + if ((err!=TIFFReadDirEntryErrOk)||(origdata==0)) + { + *value=0; + return(err); + } + switch (direntry->tdir_type) + { + case TIFF_UNDEFINED: + case TIFF_BYTE: + { + uint8* m; + uint32 n; + m=(uint8*)origdata; + for (n=0; n<count; n++) + { + err=TIFFReadDirEntryCheckRangeSbyteByte(*m); + if (err!=TIFFReadDirEntryErrOk) + { + _TIFFfree(origdata); + return(err); + } + m++; + } + *value=(int8*)origdata; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SBYTE: + *value=(int8*)origdata; + return(TIFFReadDirEntryErrOk); + } + data=(int8*)_TIFFmalloc(count); + if (data==0) + { + _TIFFfree(origdata); + return(TIFFReadDirEntryErrAlloc); + } + switch (direntry->tdir_type) + { + case TIFF_SHORT: + { + uint16* ma; + int8* mb; + uint32 n; + ma=(uint16*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort(ma); + err=TIFFReadDirEntryCheckRangeSbyteShort(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(int8)(*ma++); + } + } + break; + case TIFF_SSHORT: + { + int16* ma; + int8* mb; + uint32 n; + ma=(int16*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort((uint16*)ma); + err=TIFFReadDirEntryCheckRangeSbyteSshort(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(int8)(*ma++); + } + } + break; + case TIFF_LONG: + { + uint32* ma; + int8* mb; + uint32 n; + ma=(uint32*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(ma); + err=TIFFReadDirEntryCheckRangeSbyteLong(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(int8)(*ma++); + } + } + break; + case TIFF_SLONG: + { + int32* ma; + int8* mb; + uint32 n; + ma=(int32*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong((uint32*)ma); + err=TIFFReadDirEntryCheckRangeSbyteSlong(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(int8)(*ma++); + } + } + break; + case TIFF_LONG8: + { + uint64* ma; + int8* mb; + uint32 n; + ma=(uint64*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8(ma); + err=TIFFReadDirEntryCheckRangeSbyteLong8(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(int8)(*ma++); + } + } + break; + case TIFF_SLONG8: + { + int64* ma; + int8* mb; + uint32 n; + ma=(int64*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8((uint64*)ma); + err=TIFFReadDirEntryCheckRangeSbyteSlong8(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(int8)(*ma++); + } + } + break; + } + _TIFFfree(origdata); + if (err!=TIFFReadDirEntryErrOk) + { + _TIFFfree(data); + return(err); + } + *value=data; + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryShortArray(TIFF* tif, TIFFDirEntry* direntry, uint16** value) +{ + enum TIFFReadDirEntryErr err; + uint32 count; + void* origdata; + uint16* data; + switch (direntry->tdir_type) + { + case TIFF_BYTE: + case TIFF_SBYTE: + case TIFF_SHORT: + case TIFF_SSHORT: + case TIFF_LONG: + case TIFF_SLONG: + case TIFF_LONG8: + case TIFF_SLONG8: + break; + default: + return(TIFFReadDirEntryErrType); + } + err=TIFFReadDirEntryArray(tif,direntry,&count,2,&origdata); + if ((err!=TIFFReadDirEntryErrOk)||(origdata==0)) + { + *value=0; + return(err); + } + switch (direntry->tdir_type) + { + case TIFF_SHORT: + *value=(uint16*)origdata; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfShort(*value,count); + return(TIFFReadDirEntryErrOk); + case TIFF_SSHORT: + { + int16* m; + uint32 n; + m=(int16*)origdata; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort((uint16*)m); + err=TIFFReadDirEntryCheckRangeShortSshort(*m); + if (err!=TIFFReadDirEntryErrOk) + { + _TIFFfree(origdata); + return(err); + } + m++; + } + *value=(uint16*)origdata; + return(TIFFReadDirEntryErrOk); + } + } + data=(uint16*)_TIFFmalloc(count*2); + if (data==0) + { + _TIFFfree(origdata); + return(TIFFReadDirEntryErrAlloc); + } + switch (direntry->tdir_type) + { + case TIFF_BYTE: + { + uint8* ma; + uint16* mb; + uint32 n; + ma=(uint8*)origdata; + mb=data; + for (n=0; n<count; n++) + *mb++=(uint16)(*ma++); + } + break; + case TIFF_SBYTE: + { + int8* ma; + uint16* mb; + uint32 n; + ma=(int8*)origdata; + mb=data; + for (n=0; n<count; n++) + { + err=TIFFReadDirEntryCheckRangeShortSbyte(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(uint16)(*ma++); + } + } + break; + case TIFF_LONG: + { + uint32* ma; + uint16* mb; + uint32 n; + ma=(uint32*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(ma); + err=TIFFReadDirEntryCheckRangeShortLong(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(uint16)(*ma++); + } + } + break; + case TIFF_SLONG: + { + int32* ma; + uint16* mb; + uint32 n; + ma=(int32*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong((uint32*)ma); + err=TIFFReadDirEntryCheckRangeShortSlong(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(uint16)(*ma++); + } + } + break; + case TIFF_LONG8: + { + uint64* ma; + uint16* mb; + uint32 n; + ma=(uint64*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8(ma); + err=TIFFReadDirEntryCheckRangeShortLong8(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(uint16)(*ma++); + } + } + break; + case TIFF_SLONG8: + { + int64* ma; + uint16* mb; + uint32 n; + ma=(int64*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8((uint64*)ma); + err=TIFFReadDirEntryCheckRangeShortSlong8(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(uint16)(*ma++); + } + } + break; + } + _TIFFfree(origdata); + if (err!=TIFFReadDirEntryErrOk) + { + _TIFFfree(data); + return(err); + } + *value=data; + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntrySshortArray(TIFF* tif, TIFFDirEntry* direntry, int16** value) +{ + enum TIFFReadDirEntryErr err; + uint32 count; + void* origdata; + int16* data; + switch (direntry->tdir_type) + { + case TIFF_BYTE: + case TIFF_SBYTE: + case TIFF_SHORT: + case TIFF_SSHORT: + case TIFF_LONG: + case TIFF_SLONG: + case TIFF_LONG8: + case TIFF_SLONG8: + break; + default: + return(TIFFReadDirEntryErrType); + } + err=TIFFReadDirEntryArray(tif,direntry,&count,2,&origdata); + if ((err!=TIFFReadDirEntryErrOk)||(origdata==0)) + { + *value=0; + return(err); + } + switch (direntry->tdir_type) + { + case TIFF_SHORT: + { + uint16* m; + uint32 n; + m=(uint16*)origdata; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort(m); + err=TIFFReadDirEntryCheckRangeSshortShort(*m); + if (err!=TIFFReadDirEntryErrOk) + { + _TIFFfree(origdata); + return(err); + } + m++; + } + *value=(int16*)origdata; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SSHORT: + *value=(int16*)origdata; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfShort((uint16*)(*value),count); + return(TIFFReadDirEntryErrOk); + } + data=(int16*)_TIFFmalloc(count*2); + if (data==0) + { + _TIFFfree(origdata); + return(TIFFReadDirEntryErrAlloc); + } + switch (direntry->tdir_type) + { + case TIFF_BYTE: + { + uint8* ma; + int16* mb; + uint32 n; + ma=(uint8*)origdata; + mb=data; + for (n=0; n<count; n++) + *mb++=(int16)(*ma++); + } + break; + case TIFF_SBYTE: + { + int8* ma; + int16* mb; + uint32 n; + ma=(int8*)origdata; + mb=data; + for (n=0; n<count; n++) + *mb++=(int16)(*ma++); + } + break; + case TIFF_LONG: + { + uint32* ma; + int16* mb; + uint32 n; + ma=(uint32*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(ma); + err=TIFFReadDirEntryCheckRangeSshortLong(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(int16)(*ma++); + } + } + break; + case TIFF_SLONG: + { + int32* ma; + int16* mb; + uint32 n; + ma=(int32*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong((uint32*)ma); + err=TIFFReadDirEntryCheckRangeSshortSlong(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(int16)(*ma++); + } + } + break; + case TIFF_LONG8: + { + uint64* ma; + int16* mb; + uint32 n; + ma=(uint64*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8(ma); + err=TIFFReadDirEntryCheckRangeSshortLong8(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(int16)(*ma++); + } + } + break; + case TIFF_SLONG8: + { + int64* ma; + int16* mb; + uint32 n; + ma=(int64*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8((uint64*)ma); + err=TIFFReadDirEntryCheckRangeSshortSlong8(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(int16)(*ma++); + } + } + break; + } + _TIFFfree(origdata); + if (err!=TIFFReadDirEntryErrOk) + { + _TIFFfree(data); + return(err); + } + *value=data; + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryLongArray(TIFF* tif, TIFFDirEntry* direntry, uint32** value) +{ + enum TIFFReadDirEntryErr err; + uint32 count; + void* origdata; + uint32* data; + switch (direntry->tdir_type) + { + case TIFF_BYTE: + case TIFF_SBYTE: + case TIFF_SHORT: + case TIFF_SSHORT: + case TIFF_LONG: + case TIFF_SLONG: + case TIFF_LONG8: + case TIFF_SLONG8: + break; + default: + return(TIFFReadDirEntryErrType); + } + err=TIFFReadDirEntryArray(tif,direntry,&count,4,&origdata); + if ((err!=TIFFReadDirEntryErrOk)||(origdata==0)) + { + *value=0; + return(err); + } + switch (direntry->tdir_type) + { + case TIFF_LONG: + *value=(uint32*)origdata; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfLong(*value,count); + return(TIFFReadDirEntryErrOk); + case TIFF_SLONG: + { + int32* m; + uint32 n; + m=(int32*)origdata; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong((uint32*)m); + err=TIFFReadDirEntryCheckRangeLongSlong(*m); + if (err!=TIFFReadDirEntryErrOk) + { + _TIFFfree(origdata); + return(err); + } + m++; + } + *value=(uint32*)origdata; + return(TIFFReadDirEntryErrOk); + } + } + data=(uint32*)_TIFFmalloc(count*4); + if (data==0) + { + _TIFFfree(origdata); + return(TIFFReadDirEntryErrAlloc); + } + switch (direntry->tdir_type) + { + case TIFF_BYTE: + { + uint8* ma; + uint32* mb; + uint32 n; + ma=(uint8*)origdata; + mb=data; + for (n=0; n<count; n++) + *mb++=(uint32)(*ma++); + } + break; + case TIFF_SBYTE: + { + int8* ma; + uint32* mb; + uint32 n; + ma=(int8*)origdata; + mb=data; + for (n=0; n<count; n++) + { + err=TIFFReadDirEntryCheckRangeLongSbyte(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(uint32)(*ma++); + } + } + break; + case TIFF_SHORT: + { + uint16* ma; + uint32* mb; + uint32 n; + ma=(uint16*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort(ma); + *mb++=(uint32)(*ma++); + } + } + break; + case TIFF_SSHORT: + { + int16* ma; + uint32* mb; + uint32 n; + ma=(int16*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort((uint16*)ma); + err=TIFFReadDirEntryCheckRangeLongSshort(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(uint32)(*ma++); + } + } + break; + case TIFF_LONG8: + { + uint64* ma; + uint32* mb; + uint32 n; + ma=(uint64*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8(ma); + err=TIFFReadDirEntryCheckRangeLongLong8(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(uint32)(*ma++); + } + } + break; + case TIFF_SLONG8: + { + int64* ma; + uint32* mb; + uint32 n; + ma=(int64*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8((uint64*)ma); + err=TIFFReadDirEntryCheckRangeLongSlong8(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(uint32)(*ma++); + } + } + break; + } + _TIFFfree(origdata); + if (err!=TIFFReadDirEntryErrOk) + { + _TIFFfree(data); + return(err); + } + *value=data; + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntrySlongArray(TIFF* tif, TIFFDirEntry* direntry, int32** value) +{ + enum TIFFReadDirEntryErr err; + uint32 count; + void* origdata; + int32* data; + switch (direntry->tdir_type) + { + case TIFF_BYTE: + case TIFF_SBYTE: + case TIFF_SHORT: + case TIFF_SSHORT: + case TIFF_LONG: + case TIFF_SLONG: + case TIFF_LONG8: + case TIFF_SLONG8: + break; + default: + return(TIFFReadDirEntryErrType); + } + err=TIFFReadDirEntryArray(tif,direntry,&count,4,&origdata); + if ((err!=TIFFReadDirEntryErrOk)||(origdata==0)) + { + *value=0; + return(err); + } + switch (direntry->tdir_type) + { + case TIFF_LONG: + { + uint32* m; + uint32 n; + m=(uint32*)origdata; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong((uint32*)m); + err=TIFFReadDirEntryCheckRangeSlongLong(*m); + if (err!=TIFFReadDirEntryErrOk) + { + _TIFFfree(origdata); + return(err); + } + m++; + } + *value=(int32*)origdata; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SLONG: + *value=(int32*)origdata; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfLong((uint32*)(*value),count); + return(TIFFReadDirEntryErrOk); + } + data=(int32*)_TIFFmalloc(count*4); + if (data==0) + { + _TIFFfree(origdata); + return(TIFFReadDirEntryErrAlloc); + } + switch (direntry->tdir_type) + { + case TIFF_BYTE: + { + uint8* ma; + int32* mb; + uint32 n; + ma=(uint8*)origdata; + mb=data; + for (n=0; n<count; n++) + *mb++=(int32)(*ma++); + } + break; + case TIFF_SBYTE: + { + int8* ma; + int32* mb; + uint32 n; + ma=(int8*)origdata; + mb=data; + for (n=0; n<count; n++) + *mb++=(int32)(*ma++); + } + break; + case TIFF_SHORT: + { + uint16* ma; + int32* mb; + uint32 n; + ma=(uint16*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort(ma); + *mb++=(int32)(*ma++); + } + } + break; + case TIFF_SSHORT: + { + int16* ma; + int32* mb; + uint32 n; + ma=(int16*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort((uint16*)ma); + *mb++=(int32)(*ma++); + } + } + break; + case TIFF_LONG8: + { + uint64* ma; + int32* mb; + uint32 n; + ma=(uint64*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8(ma); + err=TIFFReadDirEntryCheckRangeSlongLong8(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(int32)(*ma++); + } + } + break; + case TIFF_SLONG8: + { + int64* ma; + int32* mb; + uint32 n; + ma=(int64*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8((uint64*)ma); + err=TIFFReadDirEntryCheckRangeSlongSlong8(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(int32)(*ma++); + } + } + break; + } + _TIFFfree(origdata); + if (err!=TIFFReadDirEntryErrOk) + { + _TIFFfree(data); + return(err); + } + *value=data; + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryLong8Array(TIFF* tif, TIFFDirEntry* direntry, uint64** value) +{ + enum TIFFReadDirEntryErr err; + uint32 count; + void* origdata; + uint64* data; + switch (direntry->tdir_type) + { + case TIFF_BYTE: + case TIFF_SBYTE: + case TIFF_SHORT: + case TIFF_SSHORT: + case TIFF_LONG: + case TIFF_SLONG: + case TIFF_LONG8: + case TIFF_SLONG8: + break; + default: + return(TIFFReadDirEntryErrType); + } + err=TIFFReadDirEntryArray(tif,direntry,&count,8,&origdata); + if ((err!=TIFFReadDirEntryErrOk)||(origdata==0)) + { + *value=0; + return(err); + } + switch (direntry->tdir_type) + { + case TIFF_LONG8: + *value=(uint64*)origdata; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfLong8(*value,count); + return(TIFFReadDirEntryErrOk); + case TIFF_SLONG8: + { + int64* m; + uint32 n; + m=(int64*)origdata; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8((uint64*)m); + err=TIFFReadDirEntryCheckRangeLong8Slong8(*m); + if (err!=TIFFReadDirEntryErrOk) + { + _TIFFfree(origdata); + return(err); + } + m++; + } + *value=(uint64*)origdata; + return(TIFFReadDirEntryErrOk); + } + } + data=(uint64*)_TIFFmalloc(count*8); + if (data==0) + { + _TIFFfree(origdata); + return(TIFFReadDirEntryErrAlloc); + } + switch (direntry->tdir_type) + { + case TIFF_BYTE: + { + uint8* ma; + uint64* mb; + uint32 n; + ma=(uint8*)origdata; + mb=data; + for (n=0; n<count; n++) + *mb++=(uint64)(*ma++); + } + break; + case TIFF_SBYTE: + { + int8* ma; + uint64* mb; + uint32 n; + ma=(int8*)origdata; + mb=data; + for (n=0; n<count; n++) + { + err=TIFFReadDirEntryCheckRangeLong8Sbyte(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(uint64)(*ma++); + } + } + break; + case TIFF_SHORT: + { + uint16* ma; + uint64* mb; + uint32 n; + ma=(uint16*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort(ma); + *mb++=(uint64)(*ma++); + } + } + break; + case TIFF_SSHORT: + { + int16* ma; + uint64* mb; + uint32 n; + ma=(int16*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort((uint16*)ma); + err=TIFFReadDirEntryCheckRangeLong8Sshort(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(uint64)(*ma++); + } + } + break; + case TIFF_LONG: + { + uint32* ma; + uint64* mb; + uint32 n; + ma=(uint32*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(ma); + *mb++=(uint64)(*ma++); + } + } + break; + case TIFF_SLONG: + { + int32* ma; + uint64* mb; + uint32 n; + ma=(int32*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong((uint32*)ma); + err=TIFFReadDirEntryCheckRangeLong8Slong(*ma); + if (err!=TIFFReadDirEntryErrOk) + break; + *mb++=(uint64)(*ma++); + } + } + break; + } + _TIFFfree(origdata); + if (err!=TIFFReadDirEntryErrOk) + { + _TIFFfree(data); + return(err); + } + *value=data; + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntrySlong8Array(TIFF* tif, TIFFDirEntry* direntry, int64** value) +{ + enum TIFFReadDirEntryErr err; + uint32 count; + void* origdata; + int64* data; + switch (direntry->tdir_type) + { + case TIFF_BYTE: + case TIFF_SBYTE: + case TIFF_SHORT: + case TIFF_SSHORT: + case TIFF_LONG: + case TIFF_SLONG: + case TIFF_LONG8: + case TIFF_SLONG8: + break; + default: + return(TIFFReadDirEntryErrType); + } + err=TIFFReadDirEntryArray(tif,direntry,&count,8,&origdata); + if ((err!=TIFFReadDirEntryErrOk)||(origdata==0)) + { + *value=0; + return(err); + } + switch (direntry->tdir_type) + { + case TIFF_LONG8: + { + uint64* m; + uint32 n; + m=(uint64*)origdata; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8(m); + err=TIFFReadDirEntryCheckRangeSlong8Long8(*m); + if (err!=TIFFReadDirEntryErrOk) + { + _TIFFfree(origdata); + return(err); + } + m++; + } + *value=(int64*)origdata; + return(TIFFReadDirEntryErrOk); + } + case TIFF_SLONG8: + *value=(int64*)origdata; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfLong8((uint64*)(*value),count); + return(TIFFReadDirEntryErrOk); + } + data=(int64*)_TIFFmalloc(count*8); + if (data==0) + { + _TIFFfree(origdata); + return(TIFFReadDirEntryErrAlloc); + } + switch (direntry->tdir_type) + { + case TIFF_BYTE: + { + uint8* ma; + int64* mb; + uint32 n; + ma=(uint8*)origdata; + mb=data; + for (n=0; n<count; n++) + *mb++=(int64)(*ma++); + } + break; + case TIFF_SBYTE: + { + int8* ma; + int64* mb; + uint32 n; + ma=(int8*)origdata; + mb=data; + for (n=0; n<count; n++) + *mb++=(int64)(*ma++); + } + break; + case TIFF_SHORT: + { + uint16* ma; + int64* mb; + uint32 n; + ma=(uint16*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort(ma); + *mb++=(int64)(*ma++); + } + } + break; + case TIFF_SSHORT: + { + int16* ma; + int64* mb; + uint32 n; + ma=(int16*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort((uint16*)ma); + *mb++=(int64)(*ma++); + } + } + break; + case TIFF_LONG: + { + uint32* ma; + int64* mb; + uint32 n; + ma=(uint32*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(ma); + *mb++=(int64)(*ma++); + } + } + break; + case TIFF_SLONG: + { + int32* ma; + int64* mb; + uint32 n; + ma=(int32*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong((uint32*)ma); + *mb++=(int64)(*ma++); + } + } + break; + } + _TIFFfree(origdata); + if (err!=TIFFReadDirEntryErrOk) + { + _TIFFfree(data); + return(err); + } + *value=data; + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryFloatArray(TIFF* tif, TIFFDirEntry* direntry, float** value) +{ + enum TIFFReadDirEntryErr err; + uint32 count; + void* origdata; + float* data; + switch (direntry->tdir_type) + { + case TIFF_BYTE: + case TIFF_SBYTE: + case TIFF_SHORT: + case TIFF_SSHORT: + case TIFF_LONG: + case TIFF_SLONG: + case TIFF_LONG8: + case TIFF_SLONG8: + case TIFF_RATIONAL: + case TIFF_SRATIONAL: + case TIFF_FLOAT: + case TIFF_DOUBLE: + break; + default: + return(TIFFReadDirEntryErrType); + } + err=TIFFReadDirEntryArray(tif,direntry,&count,4,&origdata); + if ((err!=TIFFReadDirEntryErrOk)||(origdata==0)) + { + *value=0; + return(err); + } + switch (direntry->tdir_type) + { + case TIFF_FLOAT: + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfLong((uint32*)origdata,count); + TIFFCvtIEEEDoubleToNative(tif,count,(float*)origdata); + *value=(float*)origdata; + return(TIFFReadDirEntryErrOk); + } + data=(float*)_TIFFmalloc(count*sizeof(float)); + if (data==0) + { + _TIFFfree(origdata); + return(TIFFReadDirEntryErrAlloc); + } + switch (direntry->tdir_type) + { + case TIFF_BYTE: + { + uint8* ma; + float* mb; + uint32 n; + ma=(uint8*)origdata; + mb=data; + for (n=0; n<count; n++) + *mb++=(float)(*ma++); + } + break; + case TIFF_SBYTE: + { + int8* ma; + float* mb; + uint32 n; + ma=(int8*)origdata; + mb=data; + for (n=0; n<count; n++) + *mb++=(float)(*ma++); + } + break; + case TIFF_SHORT: + { + uint16* ma; + float* mb; + uint32 n; + ma=(uint16*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort(ma); + *mb++=(float)(*ma++); + } + } + break; + case TIFF_SSHORT: + { + int16* ma; + float* mb; + uint32 n; + ma=(int16*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort((uint16*)ma); + *mb++=(float)(*ma++); + } + } + break; + case TIFF_LONG: + { + uint32* ma; + float* mb; + uint32 n; + ma=(uint32*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(ma); + *mb++=(float)(*ma++); + } + } + break; + case TIFF_SLONG: + { + int32* ma; + float* mb; + uint32 n; + ma=(int32*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong((uint32*)ma); + *mb++=(float)(*ma++); + } + } + break; + case TIFF_LONG8: + { + uint64* ma; + float* mb; + uint32 n; + ma=(uint64*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8(ma); +#if defined(__WIN32__) && (_MSC_VER < 1500) + /* + * XXX: MSVC 6.0 does not support + * conversion of 64-bit integers into + * floating point values. + */ + *mb++ = _TIFFUInt64ToFloat(*ma++); +#else + *mb++ = (float)(*ma++); +#endif + } + } + break; + case TIFF_SLONG8: + { + int64* ma; + float* mb; + uint32 n; + ma=(int64*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8((uint64*)ma); + *mb++=(float)(*ma++); + } + } + break; + case TIFF_RATIONAL: + { + uint32* ma; + uint32 maa; + uint32 mab; + float* mb; + uint32 n; + ma=(uint32*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(ma); + maa=*ma++; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(ma); + mab=*ma++; + if (mab==0) + *mb++=0.0; + else + *mb++=(float)maa/(float)mab; + } + } + break; + case TIFF_SRATIONAL: + { + uint32* ma; + int32 maa; + uint32 mab; + float* mb; + uint32 n; + ma=(uint32*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(ma); + maa=*(int32*)ma; + ma++; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(ma); + mab=*ma++; + if (mab==0) + *mb++=0.0; + else + *mb++=(float)maa/(float)mab; + } + } + break; + case TIFF_DOUBLE: + { + double* ma; + float* mb; + uint32 n; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfLong8((uint64*)origdata,count); + TIFFCvtIEEEDoubleToNative(tif,count,(double*)origdata); + ma=(double*)origdata; + mb=data; + for (n=0; n<count; n++) + *mb++=(float)(*ma++); + } + break; + } + _TIFFfree(origdata); + if (err!=TIFFReadDirEntryErrOk) + { + _TIFFfree(data); + return(err); + } + *value=data; + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr +TIFFReadDirEntryDoubleArray(TIFF* tif, TIFFDirEntry* direntry, double** value) +{ + enum TIFFReadDirEntryErr err; + uint32 count; + void* origdata; + double* data; + switch (direntry->tdir_type) + { + case TIFF_BYTE: + case TIFF_SBYTE: + case TIFF_SHORT: + case TIFF_SSHORT: + case TIFF_LONG: + case TIFF_SLONG: + case TIFF_LONG8: + case TIFF_SLONG8: + case TIFF_RATIONAL: + case TIFF_SRATIONAL: + case TIFF_FLOAT: + case TIFF_DOUBLE: + break; + default: + return(TIFFReadDirEntryErrType); + } + err=TIFFReadDirEntryArray(tif,direntry,&count,8,&origdata); + if ((err!=TIFFReadDirEntryErrOk)||(origdata==0)) + { + *value=0; + return(err); + } + switch (direntry->tdir_type) + { + case TIFF_DOUBLE: + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfLong8((uint64*)origdata,count); + TIFFCvtIEEEDoubleToNative(tif,count,(double*)origdata); + *value=(double*)origdata; + return(TIFFReadDirEntryErrOk); + } + data=(double*)_TIFFmalloc(count*sizeof(double)); + if (data==0) + { + _TIFFfree(origdata); + return(TIFFReadDirEntryErrAlloc); + } + switch (direntry->tdir_type) + { + case TIFF_BYTE: + { + uint8* ma; + double* mb; + uint32 n; + ma=(uint8*)origdata; + mb=data; + for (n=0; n<count; n++) + *mb++=(double)(*ma++); + } + break; + case TIFF_SBYTE: + { + int8* ma; + double* mb; + uint32 n; + ma=(int8*)origdata; + mb=data; + for (n=0; n<count; n++) + *mb++=(double)(*ma++); + } + break; + case TIFF_SHORT: + { + uint16* ma; + double* mb; + uint32 n; + ma=(uint16*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort(ma); + *mb++=(double)(*ma++); + } + } + break; + case TIFF_SSHORT: + { + int16* ma; + double* mb; + uint32 n; + ma=(int16*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort((uint16*)ma); + *mb++=(double)(*ma++); + } + } + break; + case TIFF_LONG: + { + uint32* ma; + double* mb; + uint32 n; + ma=(uint32*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(ma); + *mb++=(double)(*ma++); + } + } + break; + case TIFF_SLONG: + { + int32* ma; + double* mb; + uint32 n; + ma=(int32*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong((uint32*)ma); + *mb++=(double)(*ma++); + } + } + break; + case TIFF_LONG8: + { + uint64* ma; + double* mb; + uint32 n; + ma=(uint64*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8(ma); +#if defined(__WIN32__) && (_MSC_VER < 1500) + /* + * XXX: MSVC 6.0 does not support + * conversion of 64-bit integers into + * floating point values. + */ + *mb++ = _TIFFUInt64ToDouble(*ma++); +#else + *mb++ = (double)(*ma++); +#endif + } + } + break; + case TIFF_SLONG8: + { + int64* ma; + double* mb; + uint32 n; + ma=(int64*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8((uint64*)ma); + *mb++=(double)(*ma++); + } + } + break; + case TIFF_RATIONAL: + { + uint32* ma; + uint32 maa; + uint32 mab; + double* mb; + uint32 n; + ma=(uint32*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(ma); + maa=*ma++; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(ma); + mab=*ma++; + if (mab==0) + *mb++=0.0; + else + *mb++=(double)maa/(double)mab; + } + } + break; + case TIFF_SRATIONAL: + { + uint32* ma; + int32 maa; + uint32 mab; + double* mb; + uint32 n; + ma=(uint32*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(ma); + maa=*(int32*)ma; + ma++; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(ma); + mab=*ma++; + if (mab==0) + *mb++=0.0; + else + *mb++=(double)maa/(double)mab; + } + } + break; + case TIFF_FLOAT: + { + float* ma; + double* mb; + uint32 n; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfLong((uint32*)origdata,count); + TIFFCvtIEEEFloatToNative(tif,count,(float*)origdata); + ma=(float*)origdata; + mb=data; + for (n=0; n<count; n++) + *mb++=(double)(*ma++); + } + break; + } + _TIFFfree(origdata); + if (err!=TIFFReadDirEntryErrOk) + { + _TIFFfree(data); + return(err); + } + *value=data; + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryIfd8Array(TIFF* tif, TIFFDirEntry* direntry, uint64** value) +{ + enum TIFFReadDirEntryErr err; + uint32 count; + void* origdata; + uint64* data; + switch (direntry->tdir_type) + { + case TIFF_LONG: + case TIFF_LONG8: + case TIFF_IFD: + case TIFF_IFD8: + break; + default: + return(TIFFReadDirEntryErrType); + } + err=TIFFReadDirEntryArray(tif,direntry,&count,8,&origdata); + if ((err!=TIFFReadDirEntryErrOk)||(origdata==0)) + { + *value=0; + return(err); + } + switch (direntry->tdir_type) + { + case TIFF_LONG8: + case TIFF_IFD8: + *value=(uint64*)origdata; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfLong8(*value,count); + return(TIFFReadDirEntryErrOk); + } + data=(uint64*)_TIFFmalloc(count*8); + if (data==0) + { + _TIFFfree(origdata); + return(TIFFReadDirEntryErrAlloc); + } + switch (direntry->tdir_type) + { + case TIFF_LONG: + case TIFF_IFD: + { + uint32* ma; + uint64* mb; + uint32 n; + ma=(uint32*)origdata; + mb=data; + for (n=0; n<count; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(ma); + *mb++=(uint64)(*ma++); + } + } + break; + } + _TIFFfree(origdata); + if (err!=TIFFReadDirEntryErrOk) + { + _TIFFfree(data); + return(err); + } + *value=data; + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryPersampleShort(TIFF* tif, TIFFDirEntry* direntry, uint16* value) +{ + enum TIFFReadDirEntryErr err; + uint16* m; + uint16* na; + uint16 nb; + if (direntry->tdir_count<(uint64)tif->tif_dir.td_samplesperpixel) + return(TIFFReadDirEntryErrCount); + err=TIFFReadDirEntryShortArray(tif,direntry,&m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + na=m; + nb=tif->tif_dir.td_samplesperpixel; + *value=*na++; + nb--; + while (nb>0) + { + if (*na++!=*value) + { + err=TIFFReadDirEntryErrPsdif; + break; + } + nb--; + } + _TIFFfree(m); + return(err); +} + +#if 0 +static enum TIFFReadDirEntryErr TIFFReadDirEntryPersampleDouble(TIFF* tif, TIFFDirEntry* direntry, double* value) +{ + enum TIFFReadDirEntryErr err; + double* m; + double* na; + uint16 nb; + if (direntry->tdir_count<(uint64)tif->tif_dir.td_samplesperpixel) + return(TIFFReadDirEntryErrCount); + err=TIFFReadDirEntryDoubleArray(tif,direntry,&m); + if (err!=TIFFReadDirEntryErrOk) + return(err); + na=m; + nb=tif->tif_dir.td_samplesperpixel; + *value=*na++; + nb--; + while (nb>0) + { + if (*na++!=*value) + { + err=TIFFReadDirEntryErrPsdif; + break; + } + nb--; + } + _TIFFfree(m); + return(err); +} +#endif + +static void TIFFReadDirEntryCheckedByte(TIFF* tif, TIFFDirEntry* direntry, uint8* value) +{ + (void) tif; + *value=*(uint8*)(&direntry->tdir_offset); +} + +static void TIFFReadDirEntryCheckedSbyte(TIFF* tif, TIFFDirEntry* direntry, int8* value) +{ + (void) tif; + *value=*(int8*)(&direntry->tdir_offset); +} + +static void TIFFReadDirEntryCheckedShort(TIFF* tif, TIFFDirEntry* direntry, uint16* value) +{ + *value = direntry->tdir_offset.toff_short; + /* *value=*(uint16*)(&direntry->tdir_offset); */ + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort(value); +} + +static void TIFFReadDirEntryCheckedSshort(TIFF* tif, TIFFDirEntry* direntry, int16* value) +{ + *value=*(int16*)(&direntry->tdir_offset); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort((uint16*)value); +} + +static void TIFFReadDirEntryCheckedLong(TIFF* tif, TIFFDirEntry* direntry, uint32* value) +{ + *value=*(uint32*)(&direntry->tdir_offset); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(value); +} + +static void TIFFReadDirEntryCheckedSlong(TIFF* tif, TIFFDirEntry* direntry, int32* value) +{ + *value=*(int32*)(&direntry->tdir_offset); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong((uint32*)value); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedLong8(TIFF* tif, TIFFDirEntry* direntry, uint64* value) +{ + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + enum TIFFReadDirEntryErr err; + uint32 offset = direntry->tdir_offset.toff_long; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(&offset); + err=TIFFReadDirEntryData(tif,offset,8,value); + if (err!=TIFFReadDirEntryErrOk) + return(err); + } + else + *value = direntry->tdir_offset.toff_long8; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8(value); + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedSlong8(TIFF* tif, TIFFDirEntry* direntry, int64* value) +{ + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + enum TIFFReadDirEntryErr err; + uint32 offset = direntry->tdir_offset.toff_long; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(&offset); + err=TIFFReadDirEntryData(tif,offset,8,value); + if (err!=TIFFReadDirEntryErrOk) + return(err); + } + else + *value=*(int64*)(&direntry->tdir_offset); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8((uint64*)value); + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedRational(TIFF* tif, TIFFDirEntry* direntry, double* value) +{ + UInt64Aligned_t m; + + assert(sizeof(double)==8); + assert(sizeof(uint64)==8); + assert(sizeof(uint32)==4); + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + enum TIFFReadDirEntryErr err; + uint32 offset = direntry->tdir_offset.toff_long; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(&offset); + err=TIFFReadDirEntryData(tif,offset,8,m.i); + if (err!=TIFFReadDirEntryErrOk) + return(err); + } + else + m.l = direntry->tdir_offset.toff_long8; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfLong(m.i,2); + if (m.i[0]==0) + *value=0.0; + else + *value=(double)m.i[0]/(double)m.i[1]; + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedSrational(TIFF* tif, TIFFDirEntry* direntry, double* value) +{ + UInt64Aligned_t m; + assert(sizeof(double)==8); + assert(sizeof(uint64)==8); + assert(sizeof(int32)==4); + assert(sizeof(uint32)==4); + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + enum TIFFReadDirEntryErr err; + uint32 offset = direntry->tdir_offset.toff_long; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(&offset); + err=TIFFReadDirEntryData(tif,offset,8,m.i); + if (err!=TIFFReadDirEntryErrOk) + return(err); + } + else + m.l=direntry->tdir_offset.toff_long8; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfLong(m.i,2); + if ((int32)m.i[0]==0) + *value=0.0; + else + *value=(double)((int32)m.i[0])/(double)m.i[1]; + return(TIFFReadDirEntryErrOk); +} + +static void TIFFReadDirEntryCheckedFloat(TIFF* tif, TIFFDirEntry* direntry, float* value) +{ + union + { + float f; + uint32 i; + } float_union; + assert(sizeof(float)==4); + assert(sizeof(uint32)==4); + assert(sizeof(float_union)==4); + float_union.i=*(uint32*)(&direntry->tdir_offset); + *value=float_union.f; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong((uint32*)value); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckedDouble(TIFF* tif, TIFFDirEntry* direntry, double* value) +{ + assert(sizeof(double)==8); + assert(sizeof(uint64)==8); + assert(sizeof(UInt64Aligned_t)==8); + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + enum TIFFReadDirEntryErr err; + uint32 offset = direntry->tdir_offset.toff_long; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(&offset); + err=TIFFReadDirEntryData(tif,offset,8,value); + if (err!=TIFFReadDirEntryErrOk) + return(err); + } + else + { + UInt64Aligned_t uint64_union; + uint64_union.l=direntry->tdir_offset.toff_long8; + *value=uint64_union.d; + } + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8((uint64*)value); + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSbyte(int8 value) +{ + if (value<0) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteShort(uint16 value) +{ + if (value>0xFF) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSshort(int16 value) +{ + if ((value<0)||(value>0xFF)) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteLong(uint32 value) +{ + if (value>0xFF) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSlong(int32 value) +{ + if ((value<0)||(value>0xFF)) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteLong8(uint64 value) +{ + if (value>0xFF) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeByteSlong8(int64 value) +{ + if ((value<0)||(value>0xFF)) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteByte(uint8 value) +{ + if (value>0x7F) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteShort(uint16 value) +{ + if (value>0x7F) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSshort(int16 value) +{ + if ((value<-0x80)||(value>0x7F)) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteLong(uint32 value) +{ + if (value>0x7F) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSlong(int32 value) +{ + if ((value<-0x80)||(value>0x7F)) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteLong8(uint64 value) +{ + if (value>0x7F) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSbyteSlong8(int64 value) +{ + if ((value<-0x80)||(value>0x7F)) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSbyte(int8 value) +{ + if (value<0) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSshort(int16 value) +{ + if (value<0) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortLong(uint32 value) +{ + if (value>0xFFFF) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSlong(int32 value) +{ + if ((value<0)||(value>0xFFFF)) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortLong8(uint64 value) +{ + if (value>0xFFFF) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeShortSlong8(int64 value) +{ + if ((value<0)||(value>0xFFFF)) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortShort(uint16 value) +{ + if (value>0x7FFF) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortLong(uint32 value) +{ + if (value>0x7FFF) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortSlong(int32 value) +{ + if ((value<-0x8000)||(value>0x7FFF)) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortLong8(uint64 value) +{ + if (value>0x7FFF) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeSshortSlong8(int64 value) +{ + if ((value<-0x8000)||(value>0x7FFF)) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSbyte(int8 value) +{ + if (value<0) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSshort(int16 value) +{ + if (value<0) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr TIFFReadDirEntryCheckRangeLongSlong(int32 value) +{ + if (value<0) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +/* + * Largest 32-bit unsigned integer value. + */ +#if defined(__WIN32__) && defined(_MSC_VER) +# define TIFF_UINT32_MAX 0xFFFFFFFFI64 +#else +# define TIFF_UINT32_MAX 0xFFFFFFFFLL +#endif + +static enum TIFFReadDirEntryErr +TIFFReadDirEntryCheckRangeLongLong8(uint64 value) +{ + if (value > TIFF_UINT32_MAX) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr +TIFFReadDirEntryCheckRangeLongSlong8(int64 value) +{ + if ((value<0) || (value > TIFF_UINT32_MAX)) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +#undef TIFF_UINT32_MAX + +static enum TIFFReadDirEntryErr +TIFFReadDirEntryCheckRangeSlongLong(uint32 value) +{ + if (value > 0x7FFFFFFFUL) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr +TIFFReadDirEntryCheckRangeSlongLong8(uint64 value) +{ + if (value > 0x7FFFFFFFUL) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr +TIFFReadDirEntryCheckRangeSlongSlong8(int64 value) +{ + if ((value < 0L-0x80000000L) || (value > 0x7FFFFFFFL)) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr +TIFFReadDirEntryCheckRangeLong8Sbyte(int8 value) +{ + if (value < 0) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr +TIFFReadDirEntryCheckRangeLong8Sshort(int16 value) +{ + if (value < 0) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr +TIFFReadDirEntryCheckRangeLong8Slong(int32 value) +{ + if (value < 0) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +static enum TIFFReadDirEntryErr +TIFFReadDirEntryCheckRangeLong8Slong8(int64 value) +{ + if (value < 0) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +/* + * Largest 64-bit signed integer value. + */ +#if defined(__WIN32__) && defined(_MSC_VER) +# define TIFF_INT64_MAX 0x7FFFFFFFFFFFFFFFI64 +#else +# define TIFF_INT64_MAX 0x7FFFFFFFFFFFFFFFLL +#endif + +static enum TIFFReadDirEntryErr +TIFFReadDirEntryCheckRangeSlong8Long8(uint64 value) +{ + if (value > TIFF_INT64_MAX) + return(TIFFReadDirEntryErrRange); + else + return(TIFFReadDirEntryErrOk); +} + +#undef TIFF_INT64_MAX + +static enum TIFFReadDirEntryErr +TIFFReadDirEntryData(TIFF* tif, uint64 offset, tmsize_t size, void* dest) +{ + assert(size>0); + if (!isMapped(tif)) { + if (!SeekOK(tif,offset)) + return(TIFFReadDirEntryErrIo); + if (!ReadOK(tif,dest,size)) + return(TIFFReadDirEntryErrIo); + } else { + size_t ma,mb; + ma=(size_t)offset; + mb=ma+size; + if (((uint64)ma!=offset) + || (mb < ma) + || (mb - ma != (size_t) size) + || (mb < (size_t)size) + || (mb > (size_t)tif->tif_size) + ) + return(TIFFReadDirEntryErrIo); + _TIFFmemcpy(dest,tif->tif_base+ma,size); + } + return(TIFFReadDirEntryErrOk); +} + +static void TIFFReadDirEntryOutputErr(TIFF* tif, enum TIFFReadDirEntryErr err, const char* module, const char* tagname, int recover) +{ + if (!recover) { + switch (err) { + case TIFFReadDirEntryErrCount: + TIFFErrorExt(tif->tif_clientdata, module, + "Incorrect count for \"%s\"", + tagname); + break; + case TIFFReadDirEntryErrType: + TIFFErrorExt(tif->tif_clientdata, module, + "Incompatible type for \"%s\"", + tagname); + break; + case TIFFReadDirEntryErrIo: + TIFFErrorExt(tif->tif_clientdata, module, + "IO error during reading of \"%s\"", + tagname); + break; + case TIFFReadDirEntryErrRange: + TIFFErrorExt(tif->tif_clientdata, module, + "Incorrect value for \"%s\"", + tagname); + break; + case TIFFReadDirEntryErrPsdif: + TIFFErrorExt(tif->tif_clientdata, module, + "Cannot handle different values per sample for \"%s\"", + tagname); + break; + case TIFFReadDirEntryErrSizesan: + TIFFErrorExt(tif->tif_clientdata, module, + "Sanity check on size of \"%s\" value failed", + tagname); + break; + case TIFFReadDirEntryErrAlloc: + TIFFErrorExt(tif->tif_clientdata, module, + "Out of memory reading of \"%s\"", + tagname); + break; + default: + assert(0); /* we should never get here */ + break; + } + } else { + switch (err) { + case TIFFReadDirEntryErrCount: + TIFFErrorExt(tif->tif_clientdata, module, + "Incorrect count for \"%s\"; tag ignored", + tagname); + break; + case TIFFReadDirEntryErrType: + TIFFWarningExt(tif->tif_clientdata, module, + "Incompatible type for \"%s\"; tag ignored", + tagname); + break; + case TIFFReadDirEntryErrIo: + TIFFWarningExt(tif->tif_clientdata, module, + "IO error during reading of \"%s\"; tag ignored", + tagname); + break; + case TIFFReadDirEntryErrRange: + TIFFWarningExt(tif->tif_clientdata, module, + "Incorrect value for \"%s\"; tag ignored", + tagname); + break; + case TIFFReadDirEntryErrPsdif: + TIFFWarningExt(tif->tif_clientdata, module, + "Cannot handle different values per sample for \"%s\"; tag ignored", + tagname); + break; + case TIFFReadDirEntryErrSizesan: + TIFFWarningExt(tif->tif_clientdata, module, + "Sanity check on size of \"%s\" value failed; tag ignored", + tagname); + break; + case TIFFReadDirEntryErrAlloc: + TIFFWarningExt(tif->tif_clientdata, module, + "Out of memory reading of \"%s\"; tag ignored", + tagname); + break; + default: + assert(0); /* we should never get here */ + break; + } + } +} /* * Read the next TIFF directory from a file and convert it to the internal @@ -74,46 +3423,49 @@ int TIFFReadDirectory(TIFF* tif) { static const char module[] = "TIFFReadDirectory"; - - int n; - TIFFDirectory* td; - TIFFDirEntry *dp, *dir = NULL; - uint16 iv; - uint32 v; - const TIFFFieldInfo* fip; - size_t fix; + TIFFDirEntry* dir; uint16 dircount; - int diroutoforderwarning = 0, compressionknown = 0; - - tif->tif_diroff = tif->tif_nextdiroff; - /* - * Check whether we have the last offset or bad offset (IFD looping). - */ - if (!TIFFCheckDirOffset(tif, tif->tif_nextdiroff)) - return 0; - /* - * Cleanup any previous compression state. - */ - (*tif->tif_cleanup)(tif); + TIFFDirEntry* dp; + uint16 di; + const TIFFField* fip; + uint32 fii=FAILED_FII; + toff_t nextdiroff; + tif->tif_diroff=tif->tif_nextdiroff; + if (!TIFFCheckDirOffset(tif,tif->tif_nextdiroff)) + return 0; /* last offset or bad offset (IFD looping) */ + (*tif->tif_cleanup)(tif); /* cleanup any previous compression state */ tif->tif_curdir++; - dircount = TIFFFetchDirectory(tif, tif->tif_nextdiroff, - &dir, &tif->tif_nextdiroff); - if (!dircount) { - TIFFErrorExt(tif->tif_clientdata, module, - "%s: Failed to read directory at offset %u", - tif->tif_name, tif->tif_nextdiroff); + nextdiroff = tif->tif_nextdiroff; + dircount=TIFFFetchDirectory(tif,nextdiroff,&dir,&tif->tif_nextdiroff); + if (!dircount) + { + TIFFErrorExt(tif->tif_clientdata,module, + "Failed to read directory at offset " TIFF_UINT64_FORMAT,nextdiroff); return 0; } + TIFFReadDirectoryCheckOrder(tif,dir,dircount); - tif->tif_flags &= ~TIFF_BEENWRITING; /* reset before new dir */ - /* - * Setup default value and then make a pass over - * the fields to check type and tag information, - * and to extract info required to size data - * structures. A second pass is made afterwards - * to read in everthing not taken in the first pass. - */ - td = &tif->tif_dir; + /* + * Mark duplicates of any tag to be ignored (bugzilla 1994) + * to avoid certain pathological problems. + */ + { + TIFFDirEntry* ma; + uint16 mb; + for (ma=dir, mb=0; mb<dircount; ma++, mb++) + { + TIFFDirEntry* na; + uint16 nb; + for (na=ma+1, nb=mb+1; nb<dircount; na++, nb++) + { + if (ma->tdir_tag==na->tdir_tag) + na->tdir_tag=IGNORE; + } + } + } + + tif->tif_flags &= ~TIFF_BEENWRITING; /* reset before new dir */ + tif->tif_flags &= ~TIFF_BUF4WRITE; /* reset before new dir */ /* free any old stuff and reinit */ TIFFFreeDirectory(tif); TIFFDefaultDirectory(tif); @@ -123,13 +3475,14 @@ TIFFReadDirectory(TIFF* tif) * Thus we setup a default value here, even though * the TIFF spec says there is no default value. */ - TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG); - + TIFFSetField(tif,TIFFTAG_PLANARCONFIG,PLANARCONFIG_CONTIG); /* - * Sigh, we must make a separate pass through the - * directory for the following reason: - * - * We must process the Compression tag in the first pass + * Setup default value and then make a pass over + * the fields to check type and tag information, + * and to extract info required to size data + * structures. A second pass is made afterwards + * to read in everthing not taken in the first pass. + * But we must process the Compression tag first * in order to merge in codec-private tag definitions (otherwise * we may get complaints about unknown tags). However, the * Compression tag may be dependent on the SamplesPerPixel @@ -139,163 +3492,106 @@ TIFFReadDirectory(TIFF* tif) * tag value then we may end up ignoring the Compression tag * value because it has an incorrect count value (if the * true value of SamplesPerPixel is not 1). - * - * It sure would have been nice if Aldus had really thought - * this stuff through carefully. */ - for (dp = dir, n = dircount; n > 0; n--, dp++) { - if (tif->tif_flags & TIFF_SWAB) { - TIFFSwabArrayOfShort(&dp->tdir_tag, 2); - TIFFSwabArrayOfLong(&dp->tdir_count, 2); - } - if (dp->tdir_tag == TIFFTAG_SAMPLESPERPIXEL) { - if (!TIFFFetchNormalTag(tif, dp)) - goto bad; - dp->tdir_tag = IGNORE; + dp=TIFFReadDirectoryFindEntry(tif,dir,dircount,TIFFTAG_SAMPLESPERPIXEL); + if (dp) + { + if (!TIFFFetchNormalTag(tif,dp,0)) + goto bad; + dp->tdir_tag=IGNORE; + } + dp=TIFFReadDirectoryFindEntry(tif,dir,dircount,TIFFTAG_COMPRESSION); + if (dp) + { + /* + * The 5.0 spec says the Compression tag has one value, while + * earlier specs say it has one value per sample. Because of + * this, we accept the tag if one value is supplied with either + * count. + */ + uint16 value; + enum TIFFReadDirEntryErr err; + err=TIFFReadDirEntryShort(tif,dp,&value); + if (err==TIFFReadDirEntryErrCount) + err=TIFFReadDirEntryPersampleShort(tif,dp,&value); + if (err!=TIFFReadDirEntryErrOk) + { + TIFFReadDirEntryOutputErr(tif,err,module,"Compression",0); + goto bad; } + if (!TIFFSetField(tif,TIFFTAG_COMPRESSION,value)) + goto bad; + dp->tdir_tag=IGNORE; + } + else + { + if (!TIFFSetField(tif,TIFFTAG_COMPRESSION,COMPRESSION_NONE)) + goto bad; } /* * First real pass over the directory. */ - fix = 0; - for (dp = dir, n = dircount; n > 0; n--, dp++) { - - if (fix >= tif->tif_nfields || dp->tdir_tag == IGNORE) - continue; - - /* - * Silicon Beach (at least) writes unordered - * directory tags (violating the spec). Handle - * it here, but be obnoxious (maybe they'll fix it?). - */ - if (dp->tdir_tag < tif->tif_fieldinfo[fix]->field_tag) { - if (!diroutoforderwarning) { + for (di=0, dp=dir; di<dircount; di++, dp++) + { + if (dp->tdir_tag!=IGNORE) + { + TIFFReadDirectoryFindFieldInfo(tif,dp->tdir_tag,&fii); + if (fii == FAILED_FII) + { TIFFWarningExt(tif->tif_clientdata, module, - "%s: invalid TIFF directory; tags are not sorted in ascending order", - tif->tif_name); - diroutoforderwarning = 1; - } - fix = 0; /* O(n^2) */ - } - while (fix < tif->tif_nfields && - tif->tif_fieldinfo[fix]->field_tag < dp->tdir_tag) - fix++; - if (fix >= tif->tif_nfields || - tif->tif_fieldinfo[fix]->field_tag != dp->tdir_tag) { - - TIFFWarningExt(tif->tif_clientdata, - module, - "%s: unknown field with tag %d (0x%x) encountered", - tif->tif_name, - dp->tdir_tag, - dp->tdir_tag); - - if (!_TIFFMergeFieldInfo(tif, - _TIFFCreateAnonFieldInfo(tif, + "Unknown field with tag %d (0x%x) encountered", + dp->tdir_tag,dp->tdir_tag); + /* the following knowingly leaks the + anonymous field structure */ + if (!_TIFFMergeFields(tif, + _TIFFCreateAnonField(tif, dp->tdir_tag, (TIFFDataType) dp->tdir_type), - 1)) - { + 1)) { TIFFWarningExt(tif->tif_clientdata, - module, - "Registering anonymous field with tag %d (0x%x) failed", - dp->tdir_tag, - dp->tdir_tag); - goto ignore; - } - fix = 0; - while (fix < tif->tif_nfields && - tif->tif_fieldinfo[fix]->field_tag < dp->tdir_tag) - fix++; - } - /* - * Null out old tags that we ignore. - */ - if (tif->tif_fieldinfo[fix]->field_bit == FIELD_IGNORE) { - ignore: - dp->tdir_tag = IGNORE; - continue; - } - /* - * Check data type. - */ - fip = tif->tif_fieldinfo[fix]; - while (dp->tdir_type != (unsigned short) fip->field_type - && fix < tif->tif_nfields) { - if (fip->field_type == TIFF_ANY) /* wildcard */ - break; - fip = tif->tif_fieldinfo[++fix]; - if (fix >= tif->tif_nfields || - fip->field_tag != dp->tdir_tag) { - TIFFWarningExt(tif->tif_clientdata, module, - "%s: wrong data type %d for \"%s\"; tag ignored", - tif->tif_name, dp->tdir_type, - tif->tif_fieldinfo[fix-1]->field_name); - goto ignore; + module, + "Registering anonymous field with tag %d (0x%x) failed", + dp->tdir_tag, + dp->tdir_tag); + dp->tdir_tag=IGNORE; + } else { + TIFFReadDirectoryFindFieldInfo(tif,dp->tdir_tag,&fii); + assert(fii != FAILED_FII); + } } } - /* - * Check count if known in advance. - */ - if (fip->field_readcount != TIFF_VARIABLE - && fip->field_readcount != TIFF_VARIABLE2) { - uint32 expected = (fip->field_readcount == TIFF_SPP) ? - (uint32) td->td_samplesperpixel : - (uint32) fip->field_readcount; - if (!CheckDirCount(tif, dp, expected)) - goto ignore; - } - - switch (dp->tdir_tag) { - case TIFFTAG_COMPRESSION: - /* - * The 5.0 spec says the Compression tag has - * one value, while earlier specs say it has - * one value per sample. Because of this, we - * accept the tag if one value is supplied. - */ - if (dp->tdir_count == 1) { - v = TIFFExtractData(tif, - dp->tdir_type, dp->tdir_offset); - if (!TIFFSetField(tif, dp->tdir_tag, (uint16)v)) - goto bad; - else - compressionknown = 1; - break; - /* XXX: workaround for broken TIFFs */ - } else if (dp->tdir_type == TIFF_LONG) { - if (!TIFFFetchPerSampleLongs(tif, dp, &v) || - !TIFFSetField(tif, dp->tdir_tag, (uint16)v)) - goto bad; - } else { - if (!TIFFFetchPerSampleShorts(tif, dp, &iv) - || !TIFFSetField(tif, dp->tdir_tag, iv)) - goto bad; + if (dp->tdir_tag!=IGNORE) + { + fip=tif->tif_fields[fii]; + if (fip->field_bit==FIELD_IGNORE) + dp->tdir_tag=IGNORE; + else + { + switch (dp->tdir_tag) + { + case TIFFTAG_STRIPOFFSETS: + case TIFFTAG_STRIPBYTECOUNTS: + case TIFFTAG_TILEOFFSETS: + case TIFFTAG_TILEBYTECOUNTS: + TIFFSetFieldBit(tif,fip->field_bit); + break; + case TIFFTAG_IMAGEWIDTH: + case TIFFTAG_IMAGELENGTH: + case TIFFTAG_IMAGEDEPTH: + case TIFFTAG_TILELENGTH: + case TIFFTAG_TILEWIDTH: + case TIFFTAG_TILEDEPTH: + case TIFFTAG_PLANARCONFIG: + case TIFFTAG_ROWSPERSTRIP: + case TIFFTAG_EXTRASAMPLES: + if (!TIFFFetchNormalTag(tif,dp,0)) + goto bad; + dp->tdir_tag=IGNORE; + break; + } } - dp->tdir_tag = IGNORE; - break; - case TIFFTAG_STRIPOFFSETS: - case TIFFTAG_STRIPBYTECOUNTS: - case TIFFTAG_TILEOFFSETS: - case TIFFTAG_TILEBYTECOUNTS: - TIFFSetFieldBit(tif, fip->field_bit); - break; - case TIFFTAG_IMAGEWIDTH: - case TIFFTAG_IMAGELENGTH: - case TIFFTAG_IMAGEDEPTH: - case TIFFTAG_TILELENGTH: - case TIFFTAG_TILEWIDTH: - case TIFFTAG_TILEDEPTH: - case TIFFTAG_PLANARCONFIG: - case TIFFTAG_ROWSPERSTRIP: - case TIFFTAG_EXTRASAMPLES: - if (!TIFFFetchNormalTag(tif, dp)) - goto bad; - dp->tdir_tag = IGNORE; - break; } } - /* * XXX: OJPEG hack. * If a) compression is OJPEG, b) planarconfig tag says it's separate, @@ -304,55 +3600,59 @@ TIFFReadDirectory(TIFF* tif) * that the buggy implementation of the buggy compression scheme * matches contig planarconfig best. So we 'fix-up' the tag here */ - if ((td->td_compression==COMPRESSION_OJPEG) && - (td->td_planarconfig==PLANARCONFIG_SEPARATE)) { - dp = TIFFReadDirectoryFind(dir,dircount,TIFFTAG_STRIPOFFSETS); - if ((dp!=0) && (dp->tdir_count==1)) { - dp = TIFFReadDirectoryFind(dir, dircount, - TIFFTAG_STRIPBYTECOUNTS); - if ((dp!=0) && (dp->tdir_count==1)) { - td->td_planarconfig=PLANARCONFIG_CONTIG; - TIFFWarningExt(tif->tif_clientdata, - "TIFFReadDirectory", - "Planarconfig tag value assumed incorrect, " - "assuming data is contig instead of chunky"); + if ((tif->tif_dir.td_compression==COMPRESSION_OJPEG)&& + (tif->tif_dir.td_planarconfig==PLANARCONFIG_SEPARATE)) + { + if (!_TIFFFillStriles(tif)) + goto bad; + dp=TIFFReadDirectoryFindEntry(tif,dir,dircount,TIFFTAG_STRIPOFFSETS); + if ((dp!=0)&&(dp->tdir_count==1)) + { + dp=TIFFReadDirectoryFindEntry(tif,dir,dircount, + TIFFTAG_STRIPBYTECOUNTS); + if ((dp!=0)&&(dp->tdir_count==1)) + { + tif->tif_dir.td_planarconfig=PLANARCONFIG_CONTIG; + TIFFWarningExt(tif->tif_clientdata,module, + "Planarconfig tag value assumed incorrect, " + "assuming data is contig instead of chunky"); } } } - /* * Allocate directory structure and setup defaults. */ - if (!TIFFFieldSet(tif, FIELD_IMAGEDIMENSIONS)) { - MissingRequired(tif, "ImageLength"); + if (!TIFFFieldSet(tif,FIELD_IMAGEDIMENSIONS)) + { + MissingRequired(tif,"ImageLength"); goto bad; } - /* + /* * Setup appropriate structures (by strip or by tile) */ if (!TIFFFieldSet(tif, FIELD_TILEDIMENSIONS)) { - td->td_nstrips = TIFFNumberOfStrips(tif); - td->td_tilewidth = td->td_imagewidth; - td->td_tilelength = td->td_rowsperstrip; - td->td_tiledepth = td->td_imagedepth; + tif->tif_dir.td_nstrips = TIFFNumberOfStrips(tif); + tif->tif_dir.td_tilewidth = tif->tif_dir.td_imagewidth; + tif->tif_dir.td_tilelength = tif->tif_dir.td_rowsperstrip; + tif->tif_dir.td_tiledepth = tif->tif_dir.td_imagedepth; tif->tif_flags &= ~TIFF_ISTILED; } else { - td->td_nstrips = TIFFNumberOfTiles(tif); + tif->tif_dir.td_nstrips = TIFFNumberOfTiles(tif); tif->tif_flags |= TIFF_ISTILED; } - if (!td->td_nstrips) { + if (!tif->tif_dir.td_nstrips) { TIFFErrorExt(tif->tif_clientdata, module, - "%s: cannot handle zero number of %s", - tif->tif_name, isTiled(tif) ? "tiles" : "strips"); + "Cannot handle zero number of %s", + isTiled(tif) ? "tiles" : "strips"); goto bad; } - td->td_stripsperimage = td->td_nstrips; - if (td->td_planarconfig == PLANARCONFIG_SEPARATE) - td->td_stripsperimage /= td->td_samplesperpixel; + tif->tif_dir.td_stripsperimage = tif->tif_dir.td_nstrips; + if (tif->tif_dir.td_planarconfig == PLANARCONFIG_SEPARATE) + tif->tif_dir.td_stripsperimage /= tif->tif_dir.td_samplesperpixel; if (!TIFFFieldSet(tif, FIELD_STRIPOFFSETS)) { - if ((td->td_compression==COMPRESSION_OJPEG) && + if ((tif->tif_dir.td_compression==COMPRESSION_OJPEG) && (isTiled(tif)==0) && - (td->td_nstrips==1)) { + (tif->tif_dir.td_nstrips==1)) { /* * XXX: OJPEG hack. * If a) compression is OJPEG, b) it's not a tiled TIFF, @@ -368,137 +3668,150 @@ TIFFReadDirectory(TIFF* tif) goto bad; } } - /* * Second pass: extract other information. */ - for (dp = dir, n = dircount; n > 0; n--, dp++) { - if (dp->tdir_tag == IGNORE) - continue; - switch (dp->tdir_tag) { - case TIFFTAG_MINSAMPLEVALUE: - case TIFFTAG_MAXSAMPLEVALUE: - case TIFFTAG_BITSPERSAMPLE: - case TIFFTAG_DATATYPE: - case TIFFTAG_SAMPLEFORMAT: - /* - * The 5.0 spec says the Compression tag has - * one value, while earlier specs say it has - * one value per sample. Because of this, we - * accept the tag if one value is supplied. - * - * The MinSampleValue, MaxSampleValue, BitsPerSample - * DataType and SampleFormat tags are supposed to be - * written as one value/sample, but some vendors - * incorrectly write one value only -- so we accept - * that as well (yech). Other vendors write correct - * value for NumberOfSamples, but incorrect one for - * BitsPerSample and friends, and we will read this - * too. - */ - if (dp->tdir_count == 1) { - v = TIFFExtractData(tif, - dp->tdir_type, dp->tdir_offset); - if (!TIFFSetField(tif, dp->tdir_tag, (uint16)v)) - goto bad; - /* XXX: workaround for broken TIFFs */ - } else if (dp->tdir_tag == TIFFTAG_BITSPERSAMPLE - && dp->tdir_type == TIFF_LONG) { - if (!TIFFFetchPerSampleLongs(tif, dp, &v) || - !TIFFSetField(tif, dp->tdir_tag, (uint16)v)) - goto bad; - } else { - if (!TIFFFetchPerSampleShorts(tif, dp, &iv) || - !TIFFSetField(tif, dp->tdir_tag, iv)) - goto bad; - } - break; - case TIFFTAG_SMINSAMPLEVALUE: - case TIFFTAG_SMAXSAMPLEVALUE: - { - double dv = 0.0; - if (!TIFFFetchPerSampleAnys(tif, dp, &dv) || - !TIFFSetField(tif, dp->tdir_tag, dv)) - goto bad; - } - break; - case TIFFTAG_STRIPOFFSETS: - case TIFFTAG_TILEOFFSETS: - if (!TIFFFetchStripThing(tif, dp, - td->td_nstrips, &td->td_stripoffset)) - goto bad; - break; - case TIFFTAG_STRIPBYTECOUNTS: - case TIFFTAG_TILEBYTECOUNTS: - if (!TIFFFetchStripThing(tif, dp, - td->td_nstrips, &td->td_stripbytecount)) - goto bad; - break; - case TIFFTAG_COLORMAP: - case TIFFTAG_TRANSFERFUNCTION: - { - char* cp; + for (di=0, dp=dir; di<dircount; di++, dp++) + { + switch (dp->tdir_tag) + { + case IGNORE: + break; + case TIFFTAG_MINSAMPLEVALUE: + case TIFFTAG_MAXSAMPLEVALUE: + case TIFFTAG_BITSPERSAMPLE: + case TIFFTAG_DATATYPE: + case TIFFTAG_SAMPLEFORMAT: /* - * TransferFunction can have either 1x or 3x - * data values; Colormap can have only 3x - * items. + * The MinSampleValue, MaxSampleValue, BitsPerSample + * DataType and SampleFormat tags are supposed to be + * written as one value/sample, but some vendors + * incorrectly write one value only -- so we accept + * that as well (yech). Other vendors write correct + * value for NumberOfSamples, but incorrect one for + * BitsPerSample and friends, and we will read this + * too. */ - v = 1L<<td->td_bitspersample; - if (dp->tdir_tag == TIFFTAG_COLORMAP || - dp->tdir_count != v) { - if (!CheckDirCount(tif, dp, 3 * v)) - break; + { + uint16 value; + enum TIFFReadDirEntryErr err; + err=TIFFReadDirEntryShort(tif,dp,&value); + if (err==TIFFReadDirEntryErrCount) + err=TIFFReadDirEntryPersampleShort(tif,dp,&value); + if (err!=TIFFReadDirEntryErrOk) + { + fip = TIFFFieldWithTag(tif,dp->tdir_tag); + TIFFReadDirEntryOutputErr(tif,err,module,fip ? fip->field_name : "unknown tagname",0); + goto bad; + } + if (!TIFFSetField(tif,dp->tdir_tag,value)) + goto bad; } - v *= sizeof(uint16); - cp = (char *)_TIFFCheckMalloc(tif, - dp->tdir_count, - sizeof (uint16), - "to read \"TransferFunction\" tag"); - if (cp != NULL) { - if (TIFFFetchData(tif, dp, cp)) { - /* - * This deals with there being - * only one array to apply to - * all samples. - */ - uint32 c = 1L << td->td_bitspersample; - if (dp->tdir_count == c) - v = 0L; - TIFFSetField(tif, dp->tdir_tag, - cp, cp+v, cp+2*v); + break; + case TIFFTAG_SMINSAMPLEVALUE: + case TIFFTAG_SMAXSAMPLEVALUE: + { + + double *data; + enum TIFFReadDirEntryErr err; + uint32 saved_flags; + int m; + if (dp->tdir_count != (uint64)tif->tif_dir.td_samplesperpixel) + err = TIFFReadDirEntryErrCount; + else + err = TIFFReadDirEntryDoubleArray(tif, dp, &data); + if (err!=TIFFReadDirEntryErrOk) + { + fip = TIFFFieldWithTag(tif,dp->tdir_tag); + TIFFReadDirEntryOutputErr(tif,err,module,fip ? fip->field_name : "unknown tagname",0); + goto bad; } - _TIFFfree(cp); + saved_flags = tif->tif_flags; + tif->tif_flags |= TIFF_PERSAMPLE; + m = TIFFSetField(tif,dp->tdir_tag,data); + tif->tif_flags = saved_flags; + _TIFFfree(data); + if (!m) + goto bad; } break; - } - case TIFFTAG_PAGENUMBER: - case TIFFTAG_HALFTONEHINTS: - case TIFFTAG_YCBCRSUBSAMPLING: - case TIFFTAG_DOTRANGE: - (void) TIFFFetchShortPair(tif, dp); - break; - case TIFFTAG_REFERENCEBLACKWHITE: - (void) TIFFFetchRefBlackWhite(tif, dp); - break; -/* BEGIN REV 4.0 COMPATIBILITY */ - case TIFFTAG_OSUBFILETYPE: - v = 0L; - switch (TIFFExtractData(tif, dp->tdir_type, - dp->tdir_offset)) { - case OFILETYPE_REDUCEDIMAGE: - v = FILETYPE_REDUCEDIMAGE; + case TIFFTAG_STRIPOFFSETS: + case TIFFTAG_TILEOFFSETS: +#if defined(DEFER_STRILE_LOAD) + _TIFFmemcpy( &(tif->tif_dir.td_stripoffset_entry), + dp, sizeof(TIFFDirEntry) ); +#else + if (!TIFFFetchStripThing(tif,dp,tif->tif_dir.td_nstrips,&tif->tif_dir.td_stripoffset)) + goto bad; +#endif break; - case OFILETYPE_PAGE: - v = FILETYPE_PAGE; + case TIFFTAG_STRIPBYTECOUNTS: + case TIFFTAG_TILEBYTECOUNTS: +#if defined(DEFER_STRILE_LOAD) + _TIFFmemcpy( &(tif->tif_dir.td_stripbytecount_entry), + dp, sizeof(TIFFDirEntry) ); +#else + if (!TIFFFetchStripThing(tif,dp,tif->tif_dir.td_nstrips,&tif->tif_dir.td_stripbytecount)) + goto bad; +#endif + break; + case TIFFTAG_COLORMAP: + case TIFFTAG_TRANSFERFUNCTION: + { + enum TIFFReadDirEntryErr err; + uint32 countpersample; + uint32 countrequired; + uint32 incrementpersample; + uint16* value=NULL; + countpersample=(1L<<tif->tif_dir.td_bitspersample); + if ((dp->tdir_tag==TIFFTAG_TRANSFERFUNCTION)&&(dp->tdir_count==(uint64)countpersample)) + { + countrequired=countpersample; + incrementpersample=0; + } + else + { + countrequired=3*countpersample; + incrementpersample=countpersample; + } + if (dp->tdir_count!=(uint64)countrequired) + err=TIFFReadDirEntryErrCount; + else + err=TIFFReadDirEntryShortArray(tif,dp,&value); + if (err!=TIFFReadDirEntryErrOk) + { + fip = TIFFFieldWithTag(tif,dp->tdir_tag); + TIFFReadDirEntryOutputErr(tif,err,module,fip ? fip->field_name : "unknown tagname",1); + } + else + { + TIFFSetField(tif,dp->tdir_tag,value,value+incrementpersample,value+2*incrementpersample); + _TIFFfree(value); + } + } + break; +/* BEGIN REV 4.0 COMPATIBILITY */ + case TIFFTAG_OSUBFILETYPE: + { + uint16 valueo; + uint32 value; + if (TIFFReadDirEntryShort(tif,dp,&valueo)==TIFFReadDirEntryErrOk) + { + switch (valueo) + { + case OFILETYPE_REDUCEDIMAGE: value=FILETYPE_REDUCEDIMAGE; break; + case OFILETYPE_PAGE: value=FILETYPE_PAGE; break; + default: value=0; break; + } + if (value!=0) + TIFFSetField(tif,TIFFTAG_SUBFILETYPE,value); + } + } break; - } - if (v) - TIFFSetField(tif, TIFFTAG_SUBFILETYPE, v); - break; /* END REV 4.0 COMPATIBILITY */ - default: - (void) TIFFFetchNormalTag(tif, dp); - break; + default: + (void) TIFFFetchNormalTag(tif, dp, TRUE); + break; } } /* @@ -517,48 +3830,54 @@ TIFFReadDirectory(TIFF* tif) * and c) photometric is MINISWHITE or MINISBLACK, then we consistently * find samplesperpixel should be 3 */ - if (td->td_compression==COMPRESSION_OJPEG) + if (tif->tif_dir.td_compression==COMPRESSION_OJPEG) { if (!TIFFFieldSet(tif,FIELD_PHOTOMETRIC)) { - TIFFWarningExt(tif->tif_clientdata, "TIFFReadDirectory", - "Photometric tag is missing, assuming data is YCbCr"); + TIFFWarningExt(tif->tif_clientdata, module, + "Photometric tag is missing, assuming data is YCbCr"); if (!TIFFSetField(tif,TIFFTAG_PHOTOMETRIC,PHOTOMETRIC_YCBCR)) goto bad; } - else if (td->td_photometric==PHOTOMETRIC_RGB) + else if (tif->tif_dir.td_photometric==PHOTOMETRIC_RGB) { - td->td_photometric=PHOTOMETRIC_YCBCR; - TIFFWarningExt(tif->tif_clientdata, "TIFFReadDirectory", - "Photometric tag value assumed incorrect, " - "assuming data is YCbCr instead of RGB"); + tif->tif_dir.td_photometric=PHOTOMETRIC_YCBCR; + TIFFWarningExt(tif->tif_clientdata, module, + "Photometric tag value assumed incorrect, " + "assuming data is YCbCr instead of RGB"); } if (!TIFFFieldSet(tif,FIELD_BITSPERSAMPLE)) { - TIFFWarningExt(tif->tif_clientdata,"TIFFReadDirectory", - "BitsPerSample tag is missing, assuming 8 bits per sample"); + TIFFWarningExt(tif->tif_clientdata,module, + "BitsPerSample tag is missing, assuming 8 bits per sample"); if (!TIFFSetField(tif,TIFFTAG_BITSPERSAMPLE,8)) goto bad; } if (!TIFFFieldSet(tif,FIELD_SAMPLESPERPIXEL)) { - if ((td->td_photometric==PHOTOMETRIC_RGB) - || (td->td_photometric==PHOTOMETRIC_YCBCR)) + if (tif->tif_dir.td_photometric==PHOTOMETRIC_RGB) { - TIFFWarningExt(tif->tif_clientdata, - "TIFFReadDirectory", - "SamplesPerPixel tag is missing, " - "assuming correct SamplesPerPixel value is 3"); + TIFFWarningExt(tif->tif_clientdata,module, + "SamplesPerPixel tag is missing, " + "assuming correct SamplesPerPixel value is 3"); if (!TIFFSetField(tif,TIFFTAG_SAMPLESPERPIXEL,3)) goto bad; } - else if ((td->td_photometric==PHOTOMETRIC_MINISWHITE) - || (td->td_photometric==PHOTOMETRIC_MINISBLACK)) + if (tif->tif_dir.td_photometric==PHOTOMETRIC_YCBCR) { - TIFFWarningExt(tif->tif_clientdata, - "TIFFReadDirectory", - "SamplesPerPixel tag is missing, " - "assuming correct SamplesPerPixel value is 1"); + TIFFWarningExt(tif->tif_clientdata,module, + "SamplesPerPixel tag is missing, " + "applying correct SamplesPerPixel value of 3"); + if (!TIFFSetField(tif,TIFFTAG_SAMPLESPERPIXEL,3)) + goto bad; + } + else if ((tif->tif_dir.td_photometric==PHOTOMETRIC_MINISWHITE) + || (tif->tif_dir.td_photometric==PHOTOMETRIC_MINISBLACK)) + { + /* + * SamplesPerPixel tag is missing, but is not required + * by spec. Assume correct SamplesPerPixel value of 1. + */ if (!TIFFSetField(tif,TIFFTAG_SAMPLESPERPIXEL,1)) goto bad; } @@ -567,17 +3886,23 @@ TIFFReadDirectory(TIFF* tif) /* * Verify Palette image has a Colormap. */ - if (td->td_photometric == PHOTOMETRIC_PALETTE && + if (tif->tif_dir.td_photometric == PHOTOMETRIC_PALETTE && !TIFFFieldSet(tif, FIELD_COLORMAP)) { - MissingRequired(tif, "Colormap"); - goto bad; + if ( tif->tif_dir.td_bitspersample>=8 && tif->tif_dir.td_samplesperpixel==3) + tif->tif_dir.td_photometric = PHOTOMETRIC_RGB; + else if (tif->tif_dir.td_bitspersample>=8) + tif->tif_dir.td_photometric = PHOTOMETRIC_MINISBLACK; + else { + MissingRequired(tif, "Colormap"); + goto bad; + } } /* * OJPEG hack: * We do no further messing with strip/tile offsets/bytecounts in OJPEG * TIFFs */ - if (td->td_compression!=COMPRESSION_OJPEG) + if (tif->tif_dir.td_compression!=COMPRESSION_OJPEG) { /* * Attempt to deal with a missing StripByteCounts tag. @@ -588,18 +3913,16 @@ TIFFReadDirectory(TIFF* tif) * the size of the strips. In this case, assume there * is one uncompressed strip of data. */ - if ((td->td_planarconfig == PLANARCONFIG_CONTIG && - td->td_nstrips > 1) || - (td->td_planarconfig == PLANARCONFIG_SEPARATE && - td->td_nstrips != td->td_samplesperpixel)) { + if ((tif->tif_dir.td_planarconfig == PLANARCONFIG_CONTIG && + tif->tif_dir.td_nstrips > 1) || + (tif->tif_dir.td_planarconfig == PLANARCONFIG_SEPARATE && + tif->tif_dir.td_nstrips != (uint32)tif->tif_dir.td_samplesperpixel)) { MissingRequired(tif, "StripByteCounts"); goto bad; } TIFFWarningExt(tif->tif_clientdata, module, - "%s: TIFF directory is missing required " - "\"%s\" field, calculating from imagelength", - tif->tif_name, - _TIFFFieldWithTag(tif,TIFFTAG_STRIPBYTECOUNTS)->field_name); + "TIFF directory is missing required " + "\"StripByteCounts\" field, calculating from imagelength"); if (EstimateStripByteCounts(tif, dir, dircount) < 0) goto bad; /* @@ -616,15 +3939,16 @@ TIFFReadDirectory(TIFF* tif) * dumped out. */ #define BYTECOUNTLOOKSBAD \ - ( (td->td_stripbytecount[0] == 0 && td->td_stripoffset[0] != 0) || \ - (td->td_compression == COMPRESSION_NONE && \ - td->td_stripbytecount[0] > TIFFGetFileSize(tif) - td->td_stripoffset[0]) || \ + ( (tif->tif_dir.td_stripbytecount[0] == 0 && tif->tif_dir.td_stripoffset[0] != 0) || \ + (tif->tif_dir.td_compression == COMPRESSION_NONE && \ + tif->tif_dir.td_stripbytecount[0] > TIFFGetFileSize(tif) - tif->tif_dir.td_stripoffset[0]) || \ (tif->tif_mode == O_RDONLY && \ - td->td_compression == COMPRESSION_NONE && \ - td->td_stripbytecount[0] < TIFFScanlineSize(tif) * td->td_imagelength) ) + tif->tif_dir.td_compression == COMPRESSION_NONE && \ + tif->tif_dir.td_stripbytecount[0] < TIFFScanlineSize64(tif) * tif->tif_dir.td_imagelength) ) - } else if (td->td_nstrips == 1 - && td->td_stripoffset[0] != 0 + } else if (tif->tif_dir.td_nstrips == 1 + && _TIFFFillStriles(tif) + && tif->tif_dir.td_stripoffset[0] != 0 && BYTECOUNTLOOKSBAD) { /* * XXX: Plexus (and others) sometimes give a value of @@ -633,61 +3957,71 @@ TIFFReadDirectory(TIFF* tif) * of estimating the size of a one strip image. */ TIFFWarningExt(tif->tif_clientdata, module, - "%s: Bogus \"%s\" field, ignoring and calculating from imagelength", - tif->tif_name, - _TIFFFieldWithTag(tif,TIFFTAG_STRIPBYTECOUNTS)->field_name); + "Bogus \"StripByteCounts\" field, ignoring and calculating from imagelength"); if(EstimateStripByteCounts(tif, dir, dircount) < 0) goto bad; - } else if (td->td_planarconfig == PLANARCONFIG_CONTIG - && td->td_nstrips > 2 - && td->td_compression == COMPRESSION_NONE - && td->td_stripbytecount[0] != td->td_stripbytecount[1] - && td->td_stripbytecount[0] != 0 - && td->td_stripbytecount[1] != 0 ) { + +#if !defined(DEFER_STRILE_LOAD) + } else if (tif->tif_dir.td_planarconfig == PLANARCONFIG_CONTIG + && tif->tif_dir.td_nstrips > 2 + && tif->tif_dir.td_compression == COMPRESSION_NONE + && tif->tif_dir.td_stripbytecount[0] != tif->tif_dir.td_stripbytecount[1] + && tif->tif_dir.td_stripbytecount[0] != 0 + && tif->tif_dir.td_stripbytecount[1] != 0 ) { /* - * XXX: Some vendors fill StripByteCount array with - * absolutely wrong values (it can be equal to - * StripOffset array, for example). Catch this case - * here. + * XXX: Some vendors fill StripByteCount array with + * absolutely wrong values (it can be equal to + * StripOffset array, for example). Catch this case + * here. + * + * We avoid this check if deferring strile loading + * as it would always force us to load the strip/tile + * information. */ TIFFWarningExt(tif->tif_clientdata, module, - "%s: Wrong \"%s\" field, ignoring and calculating from imagelength", - tif->tif_name, - _TIFFFieldWithTag(tif,TIFFTAG_STRIPBYTECOUNTS)->field_name); + "Wrong \"StripByteCounts\" field, ignoring and calculating from imagelength"); if (EstimateStripByteCounts(tif, dir, dircount) < 0) goto bad; +#endif /* !defined(DEFER_STRILE_LOAD) */ } } - if (dir) { - _TIFFfree((char *)dir); - dir = NULL; + if (dir) + { + _TIFFfree(dir); + dir=NULL; } if (!TIFFFieldSet(tif, FIELD_MAXSAMPLEVALUE)) - td->td_maxsamplevalue = (uint16)((1L<<td->td_bitspersample)-1); - /* - * Setup default compression scheme. - */ - + { + if (tif->tif_dir.td_bitspersample>=16) + tif->tif_dir.td_maxsamplevalue=0xFFFF; + else + tif->tif_dir.td_maxsamplevalue = (uint16)((1L<<tif->tif_dir.td_bitspersample)-1); + } /* * XXX: We can optimize checking for the strip bounds using the sorted * bytecounts array. See also comments for TIFFAppendToStrip() * function in tif_write.c. */ - if (td->td_nstrips > 1) { - tstrip_t strip; - - td->td_stripbytecountsorted = 1; - for (strip = 1; strip < td->td_nstrips; strip++) { - if (td->td_stripoffset[strip - 1] > - td->td_stripoffset[strip]) { - td->td_stripbytecountsorted = 0; +#if !defined(DEFER_STRILE_LOAD) + if (tif->tif_dir.td_nstrips > 1) { + uint32 strip; + + tif->tif_dir.td_stripbytecountsorted = 1; + for (strip = 1; strip < tif->tif_dir.td_nstrips; strip++) { + if (tif->tif_dir.td_stripoffset[strip - 1] > + tif->tif_dir.td_stripoffset[strip]) { + tif->tif_dir.td_stripbytecountsorted = 0; break; } } } +#endif /* !defined(DEFER_STRILE_LOAD) */ + + /* + * An opportunity for compression mode dependent tag fixup + */ + (*tif->tif_fixuptags)(tif); - if (!TIFFFieldSet(tif, FIELD_COMPRESSION)) - TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE); /* * Some manufacturers make life difficult by writing * large amounts of uncompressed data as a single strip. @@ -697,24 +4031,35 @@ TIFFReadDirectory(TIFF* tif) * side effect, however, is that the RowsPerStrip tag * value may be changed. */ - if (td->td_nstrips == 1 && td->td_compression == COMPRESSION_NONE && - (tif->tif_flags & (TIFF_STRIPCHOP|TIFF_ISTILED)) == TIFF_STRIPCHOP) + if ((tif->tif_dir.td_planarconfig==PLANARCONFIG_CONTIG)&& + (tif->tif_dir.td_nstrips==1)&& + (tif->tif_dir.td_compression==COMPRESSION_NONE)&& + ((tif->tif_flags&(TIFF_STRIPCHOP|TIFF_ISTILED))==TIFF_STRIPCHOP)) + { + if ( !_TIFFFillStriles(tif) || !tif->tif_dir.td_stripbytecount ) + return 0; ChopUpSingleUncompressedStrip(tif); + } + + /* + * Clear the dirty directory flag. + */ + tif->tif_flags &= ~TIFF_DIRTYDIRECT; + tif->tif_flags &= ~TIFF_DIRTYSTRIP; /* * Reinitialize i/o since we are starting on a new directory. */ tif->tif_row = (uint32) -1; - tif->tif_curstrip = (tstrip_t) -1; + tif->tif_curstrip = (uint32) -1; tif->tif_col = (uint32) -1; - tif->tif_curtile = (ttile_t) -1; - tif->tif_tilesize = (tsize_t) -1; + tif->tif_curtile = (uint32) -1; + tif->tif_tilesize = (tmsize_t) -1; tif->tif_scanlinesize = TIFFScanlineSize(tif); if (!tif->tif_scanlinesize) { TIFFErrorExt(tif->tif_clientdata, module, - "%s: cannot handle zero scanline size", - tif->tif_name); + "Cannot handle zero scanline size"); return (0); } @@ -722,15 +4067,13 @@ TIFFReadDirectory(TIFF* tif) tif->tif_tilesize = TIFFTileSize(tif); if (!tif->tif_tilesize) { TIFFErrorExt(tif->tif_clientdata, module, - "%s: cannot handle zero tile size", - tif->tif_name); + "Cannot handle zero tile size"); return (0); } } else { if (!TIFFStripSize(tif)) { TIFFErrorExt(tif->tif_clientdata, module, - "%s: cannot handle zero strip size", - tif->tif_name); + "Cannot handle zero strip size"); return (0); } } @@ -741,11 +4084,32 @@ bad: return (0); } +static void +TIFFReadDirectoryCheckOrder(TIFF* tif, TIFFDirEntry* dir, uint16 dircount) +{ + static const char module[] = "TIFFReadDirectoryCheckOrder"; + uint16 m; + uint16 n; + TIFFDirEntry* o; + m=0; + for (n=0, o=dir; n<dircount; n++, o++) + { + if (o->tdir_tag<m) + { + TIFFWarningExt(tif->tif_clientdata,module, + "Invalid TIFF directory; tags are not sorted in ascending order"); + break; + } + m=o->tdir_tag+1; + } +} + static TIFFDirEntry* -TIFFReadDirectoryFind(TIFFDirEntry* dir, uint16 dircount, uint16 tagid) +TIFFReadDirectoryFindEntry(TIFF* tif, TIFFDirEntry* dir, uint16 dircount, uint16 tagid) { TIFFDirEntry* m; uint16 n; + (void) tif; for (m=dir, n=0; n<dircount; m++, n++) { if (m->tdir_tag==tagid) @@ -754,123 +4118,140 @@ TIFFReadDirectoryFind(TIFFDirEntry* dir, uint16 dircount, uint16 tagid) return(0); } +static void +TIFFReadDirectoryFindFieldInfo(TIFF* tif, uint16 tagid, uint32* fii) +{ + int32 ma,mb,mc; + ma=-1; + mc=(int32)tif->tif_nfields; + while (1) + { + if (ma+1==mc) + { + *fii = FAILED_FII; + return; + } + mb=(ma+mc)/2; + if (tif->tif_fields[mb]->field_tag==(uint32)tagid) + break; + if (tif->tif_fields[mb]->field_tag<(uint32)tagid) + ma=mb; + else + mc=mb; + } + while (1) + { + if (mb==0) + break; + if (tif->tif_fields[mb-1]->field_tag!=(uint32)tagid) + break; + mb--; + } + *fii=mb; +} + /* * Read custom directory from the arbitarry offset. * The code is very similar to TIFFReadDirectory(). */ int TIFFReadCustomDirectory(TIFF* tif, toff_t diroff, - const TIFFFieldInfo info[], size_t n) + const TIFFFieldArray* infoarray) { static const char module[] = "TIFFReadCustomDirectory"; - - TIFFDirectory* td = &tif->tif_dir; - TIFFDirEntry *dp, *dir = NULL; - const TIFFFieldInfo* fip; - size_t fix; - uint16 i, dircount; - - _TIFFSetupFieldInfo(tif, info, n); - - dircount = TIFFFetchDirectory(tif, diroff, &dir, NULL); - if (!dircount) { - TIFFErrorExt(tif->tif_clientdata, module, - "%s: Failed to read custom directory at offset %u", - tif->tif_name, diroff); + TIFFDirEntry* dir; + uint16 dircount; + TIFFDirEntry* dp; + uint16 di; + const TIFFField* fip; + uint32 fii; + _TIFFSetupFields(tif, infoarray); + dircount=TIFFFetchDirectory(tif,diroff,&dir,NULL); + if (!dircount) + { + TIFFErrorExt(tif->tif_clientdata,module, + "Failed to read custom directory at offset " TIFF_UINT64_FORMAT,diroff); return 0; } - TIFFFreeDirectory(tif); - _TIFFmemset(&tif->tif_dir, 0, sizeof(TIFFDirectory)); - - fix = 0; - for (dp = dir, i = dircount; i > 0; i--, dp++) { - if (tif->tif_flags & TIFF_SWAB) { - TIFFSwabArrayOfShort(&dp->tdir_tag, 2); - TIFFSwabArrayOfLong(&dp->tdir_count, 2); - } - - if (fix >= tif->tif_nfields || dp->tdir_tag == IGNORE) - continue; - - while (fix < tif->tif_nfields && - tif->tif_fieldinfo[fix]->field_tag < dp->tdir_tag) - fix++; - - if (fix >= tif->tif_nfields || - tif->tif_fieldinfo[fix]->field_tag != dp->tdir_tag) { - + _TIFFmemset(&tif->tif_dir, 0, sizeof(TIFFDirectory)); + TIFFReadDirectoryCheckOrder(tif,dir,dircount); + for (di=0, dp=dir; di<dircount; di++, dp++) + { + TIFFReadDirectoryFindFieldInfo(tif,dp->tdir_tag,&fii); + if (fii == FAILED_FII) + { TIFFWarningExt(tif->tif_clientdata, module, - "%s: unknown field with tag %d (0x%x) encountered", - tif->tif_name, dp->tdir_tag, dp->tdir_tag); - if (!_TIFFMergeFieldInfo(tif, - _TIFFCreateAnonFieldInfo(tif, - dp->tdir_tag, - (TIFFDataType) dp->tdir_type), - 1)) - { + "Unknown field with tag %d (0x%x) encountered", + dp->tdir_tag, dp->tdir_tag); + if (!_TIFFMergeFields(tif, _TIFFCreateAnonField(tif, + dp->tdir_tag, + (TIFFDataType) dp->tdir_type), + 1)) { TIFFWarningExt(tif->tif_clientdata, module, - "Registering anonymous field with tag %d (0x%x) failed", - dp->tdir_tag, dp->tdir_tag); - goto ignore; + "Registering anonymous field with tag %d (0x%x) failed", + dp->tdir_tag, dp->tdir_tag); + dp->tdir_tag=IGNORE; + } else { + TIFFReadDirectoryFindFieldInfo(tif,dp->tdir_tag,&fii); + assert( fii != FAILED_FII ); } - - fix = 0; - while (fix < tif->tif_nfields && - tif->tif_fieldinfo[fix]->field_tag < dp->tdir_tag) - fix++; } - /* - * Null out old tags that we ignore. - */ - if (tif->tif_fieldinfo[fix]->field_bit == FIELD_IGNORE) { - ignore: - dp->tdir_tag = IGNORE; - continue; - } - /* - * Check data type. - */ - fip = tif->tif_fieldinfo[fix]; - while (dp->tdir_type != (unsigned short) fip->field_type - && fix < tif->tif_nfields) { - if (fip->field_type == TIFF_ANY) /* wildcard */ - break; - fip = tif->tif_fieldinfo[++fix]; - if (fix >= tif->tif_nfields || - fip->field_tag != dp->tdir_tag) { - TIFFWarningExt(tif->tif_clientdata, module, - "%s: wrong data type %d for \"%s\"; tag ignored", - tif->tif_name, dp->tdir_type, - tif->tif_fieldinfo[fix-1]->field_name); - goto ignore; + if (dp->tdir_tag!=IGNORE) + { + fip=tif->tif_fields[fii]; + if (fip->field_bit==FIELD_IGNORE) + dp->tdir_tag=IGNORE; + else + { + /* check data type */ + while ((fip->field_type!=TIFF_ANY)&&(fip->field_type!=dp->tdir_type)) + { + fii++; + if ((fii==tif->tif_nfields)|| + (tif->tif_fields[fii]->field_tag!=(uint32)dp->tdir_tag)) + { + fii=0xFFFF; + break; + } + fip=tif->tif_fields[fii]; + } + if (fii==0xFFFF) + { + TIFFWarningExt(tif->tif_clientdata, module, + "Wrong data type %d for \"%s\"; tag ignored", + dp->tdir_type,fip->field_name); + dp->tdir_tag=IGNORE; + } + else + { + /* check count if known in advance */ + if ((fip->field_readcount!=TIFF_VARIABLE)&& + (fip->field_readcount!=TIFF_VARIABLE2)) + { + uint32 expected; + if (fip->field_readcount==TIFF_SPP) + expected=(uint32)tif->tif_dir.td_samplesperpixel; + else + expected=(uint32)fip->field_readcount; + if (!CheckDirCount(tif,dp,expected)) + dp->tdir_tag=IGNORE; + } + } + } + switch (dp->tdir_tag) + { + case IGNORE: + break; + case EXIFTAG_SUBJECTDISTANCE: + (void) TIFFFetchSubjectDistance(tif,dp); + break; + default: + (void) TIFFFetchNormalTag(tif, dp, TRUE); + break; } - } - /* - * Check count if known in advance. - */ - if (fip->field_readcount != TIFF_VARIABLE - && fip->field_readcount != TIFF_VARIABLE2) { - uint32 expected = (fip->field_readcount == TIFF_SPP) ? - (uint32) td->td_samplesperpixel : - (uint32) fip->field_readcount; - if (!CheckDirCount(tif, dp, expected)) - goto ignore; - } - - /* - * EXIF tags which need to be specifically processed. - */ - switch (dp->tdir_tag) { - case EXIFTAG_SUBJECTDISTANCE: - (void) TIFFFetchSubjectDistance(tif, dp); - break; - default: - (void) TIFFFetchNormalTag(tif, dp); - break; } } - if (dir) _TIFFfree(dir); return 1; @@ -883,11 +4264,9 @@ TIFFReadCustomDirectory(TIFF* tif, toff_t diroff, int TIFFReadEXIFDirectory(TIFF* tif, toff_t diroff) { - size_t exifFieldInfoCount; - const TIFFFieldInfo *exifFieldInfo = - _TIFFGetExifFieldInfo(&exifFieldInfoCount); - return TIFFReadCustomDirectory(tif, diroff, exifFieldInfo, - exifFieldInfoCount); + const TIFFFieldArray* exifFieldArray; + exifFieldArray = _TIFFGetExifFields(); + return TIFFReadCustomDirectory(tif, diroff, exifFieldArray); } static int @@ -899,35 +4278,49 @@ EstimateStripByteCounts(TIFF* tif, TIFFDirEntry* dir, uint16 dircount) TIFFDirectory *td = &tif->tif_dir; uint32 strip; + _TIFFFillStriles( tif ); + if (td->td_stripbytecount) _TIFFfree(td->td_stripbytecount); - td->td_stripbytecount = (uint32*) - _TIFFCheckMalloc(tif, td->td_nstrips, sizeof (uint32), + td->td_stripbytecount = (uint64*) + _TIFFCheckMalloc(tif, td->td_nstrips, sizeof (uint64), "for \"StripByteCounts\" array"); if( td->td_stripbytecount == NULL ) return -1; if (td->td_compression != COMPRESSION_NONE) { - uint32 space = (uint32)(sizeof (TIFFHeader) - + sizeof (uint16) - + (dircount * sizeof (TIFFDirEntry)) - + sizeof (uint32)); - toff_t filesize = TIFFGetFileSize(tif); + uint64 space; + uint64 filesize; uint16 n; - + filesize = TIFFGetFileSize(tif); + if (!(tif->tif_flags&TIFF_BIGTIFF)) + space=sizeof(TIFFHeaderClassic)+2+dircount*12+4; + else + space=sizeof(TIFFHeaderBig)+8+dircount*20+8; /* calculate amount of space used by indirect values */ for (dp = dir, n = dircount; n > 0; n--, dp++) { - uint32 cc = TIFFDataWidth((TIFFDataType) dp->tdir_type); - if (cc == 0) { + uint32 typewidth = TIFFDataWidth((TIFFDataType) dp->tdir_type); + uint64 datasize; + typewidth = TIFFDataWidth((TIFFDataType) dp->tdir_type); + if (typewidth == 0) { TIFFErrorExt(tif->tif_clientdata, module, - "%s: Cannot determine size of unknown tag type %d", - tif->tif_name, dp->tdir_type); + "Cannot determine size of unknown tag type %d", + dp->tdir_type); return -1; } - cc = cc * dp->tdir_count; - if (cc > sizeof (uint32)) - space += cc; + datasize=(uint64)typewidth*dp->tdir_count; + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + if (datasize<=4) + datasize=0; + } + else + { + if (datasize<=8) + datasize=0; + } + space+=datasize; } space = filesize - space; if (td->td_planarconfig == PLANARCONFIG_SEPARATE) @@ -940,19 +4333,17 @@ EstimateStripByteCounts(TIFF* tif, TIFFDirEntry* dir, uint16 dircount) * should begin. Since a strip of data must be contiguous, * it's safe to assume that we've overestimated the amount * of data in the strip and trim this number back accordingly. - */ + */ strip--; - if (((toff_t)(td->td_stripoffset[strip]+ - td->td_stripbytecount[strip])) > filesize) - td->td_stripbytecount[strip] = - filesize - td->td_stripoffset[strip]; + if (td->td_stripoffset[strip]+td->td_stripbytecount[strip] > filesize) + td->td_stripbytecount[strip] = filesize - td->td_stripoffset[strip]; } else if (isTiled(tif)) { - uint32 bytespertile = TIFFTileSize(tif); + uint64 bytespertile = TIFFTileSize64(tif); for (strip = 0; strip < td->td_nstrips; strip++) - td->td_stripbytecount[strip] = bytespertile; + td->td_stripbytecount[strip] = bytespertile; } else { - uint32 rowbytes = TIFFScanlineSize(tif); + uint64 rowbytes = TIFFScanlineSize64(tif); uint32 rowsperstrip = td->td_imagelength/td->td_stripsperimage; for (strip = 0; strip < td->td_nstrips; strip++) td->td_stripbytecount[strip] = rowbytes * rowsperstrip; @@ -969,8 +4360,8 @@ MissingRequired(TIFF* tif, const char* tagname) static const char module[] = "MissingRequired"; TIFFErrorExt(tif->tif_clientdata, module, - "%s: TIFF directory is missing required \"%s\" field", - tif->tif_name, tagname); + "TIFF directory is missing required \"%s\" field", + tagname); } /* @@ -980,7 +4371,7 @@ MissingRequired(TIFF* tif, const char* tagname) * seen directories and check every IFD offset against that list. */ static int -TIFFCheckDirOffset(TIFF* tif, toff_t diroff) +TIFFCheckDirOffset(TIFF* tif, uint64 diroff) { uint16 n; @@ -995,17 +4386,14 @@ TIFFCheckDirOffset(TIFF* tif, toff_t diroff) tif->tif_dirnumber++; if (tif->tif_dirnumber > tif->tif_dirlistsize) { - toff_t* new_dirlist; + uint64* new_dirlist; /* * XXX: Reduce memory allocation granularity of the dirlist * array. */ - new_dirlist = (toff_t *)_TIFFCheckRealloc(tif, - tif->tif_dirlist, - tif->tif_dirnumber, - 2 * sizeof(toff_t), - "for IFD list"); + new_dirlist = (uint64*)_TIFFCheckRealloc(tif, tif->tif_dirlist, + tif->tif_dirnumber, 2 * sizeof(uint64), "for IFD list"); if (!new_dirlist) return 0; tif->tif_dirlistsize = 2 * tif->tif_dirnumber; @@ -1024,17 +4412,20 @@ TIFFCheckDirOffset(TIFF* tif, toff_t diroff) static int CheckDirCount(TIFF* tif, TIFFDirEntry* dir, uint32 count) { - if (count > dir->tdir_count) { + if ((uint64)count > dir->tdir_count) { + const TIFFField* fip = TIFFFieldWithTag(tif, dir->tdir_tag); TIFFWarningExt(tif->tif_clientdata, tif->tif_name, - "incorrect count for field \"%s\" (%u, expecting %u); tag ignored", - _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name, + "incorrect count for field \"%s\" (" TIFF_UINT64_FORMAT ", expecting %u); tag ignored", + fip ? fip->field_name : "unknown tagname", dir->tdir_count, count); return (0); - } else if (count < dir->tdir_count) { + } else if ((uint64)count < dir->tdir_count) { + const TIFFField* fip = TIFFFieldWithTag(tif, dir->tdir_tag); TIFFWarningExt(tif->tif_clientdata, tif->tif_name, - "incorrect count for field \"%s\" (%u, expecting %u); tag trimmed", - _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name, + "incorrect count for field \"%s\" (" TIFF_UINT64_FORMAT ", expecting %u); tag trimmed", + fip ? fip->field_name : "unknown tagname", dir->tdir_count, count); + dir->tdir_count = count; return (1); } return (1); @@ -1046,13 +4437,18 @@ CheckDirCount(TIFF* tif, TIFFDirEntry* dir, uint32 count) * number of fields in the directory or 0 if failed. */ static uint16 -TIFFFetchDirectory(TIFF* tif, toff_t diroff, TIFFDirEntry **pdir, - toff_t *nextdiroff) +TIFFFetchDirectory(TIFF* tif, uint64 diroff, TIFFDirEntry** pdir, + uint64 *nextdiroff) { static const char module[] = "TIFFFetchDirectory"; - TIFFDirEntry *dir; - uint16 dircount; + void* origdir; + uint16 dircount16; + uint32 dirsize; + TIFFDirEntry* dir; + uint8* ma; + TIFFDirEntry* mb; + uint16 n; assert(pdir); @@ -1066,24 +4462,51 @@ TIFFFetchDirectory(TIFF* tif, toff_t diroff, TIFFDirEntry **pdir, tif->tif_name); return 0; } - if (!ReadOK(tif, &dircount, sizeof (uint16))) { - TIFFErrorExt(tif->tif_clientdata, module, - "%s: Can not read TIFF directory count", - tif->tif_name); - return 0; + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + if (!ReadOK(tif, &dircount16, sizeof (uint16))) { + TIFFErrorExt(tif->tif_clientdata, module, + "%s: Can not read TIFF directory count", + tif->tif_name); + return 0; + } + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabShort(&dircount16); + if (dircount16>4096) + { + TIFFErrorExt(tif->tif_clientdata, module, + "Sanity check on directory count failed, this is probably not a valid IFD offset"); + return 0; + } + dirsize = 12; + } else { + uint64 dircount64; + if (!ReadOK(tif, &dircount64, sizeof (uint64))) { + TIFFErrorExt(tif->tif_clientdata, module, + "%s: Can not read TIFF directory count", + tif->tif_name); + return 0; + } + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabLong8(&dircount64); + if (dircount64>4096) + { + TIFFErrorExt(tif->tif_clientdata, module, + "Sanity check on directory count failed, this is probably not a valid IFD offset"); + return 0; + } + dircount16 = (uint16)dircount64; + dirsize = 20; } - if (tif->tif_flags & TIFF_SWAB) - TIFFSwabShort(&dircount); - dir = (TIFFDirEntry *)_TIFFCheckMalloc(tif, dircount, - sizeof (TIFFDirEntry), - "to read TIFF directory"); - if (dir == NULL) + origdir = _TIFFCheckMalloc(tif, dircount16, + dirsize, "to read TIFF directory"); + if (origdir == NULL) return 0; - if (!ReadOK(tif, dir, dircount*sizeof (TIFFDirEntry))) { + if (!ReadOK(tif, origdir, (tmsize_t)(dircount16*dirsize))) { TIFFErrorExt(tif->tif_clientdata, module, "%.100s: Can not read TIFF directory", tif->tif_name); - _TIFFfree(dir); + _TIFFfree(origdir); return 0; } /* @@ -1091,9 +4514,30 @@ TIFFFetchDirectory(TIFF* tif, toff_t diroff, TIFFDirEntry **pdir, * needed. */ if (nextdiroff) - (void) ReadOK(tif, nextdiroff, sizeof(uint32)); + { + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + uint32 nextdiroff32; + if (!ReadOK(tif, &nextdiroff32, sizeof(uint32))) + nextdiroff32 = 0; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(&nextdiroff32); + *nextdiroff=nextdiroff32; + } else { + if (!ReadOK(tif, nextdiroff, sizeof(uint64))) + *nextdiroff = 0; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8(nextdiroff); + } + } } else { - toff_t off = tif->tif_diroff; + tmsize_t m; + tmsize_t off = (tmsize_t) tif->tif_diroff; + if ((uint64)off!=tif->tif_diroff) + { + TIFFErrorExt(tif->tif_clientdata,module,"Can not read TIFF directory count"); + return(0); + } /* * Check for integer overflow when validating the dir_off, @@ -1104,809 +4548,856 @@ TIFFFetchDirectory(TIFF* tif, toff_t diroff, TIFFDirEntry **pdir, * * to avoid overflow. */ - if (tif->tif_size < sizeof (uint16) || - off > tif->tif_size - sizeof(uint16)) { + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + m=off+sizeof(uint16); + if ((m<off)||(m<(tmsize_t)sizeof(uint16))||(m>tif->tif_size)) { + TIFFErrorExt(tif->tif_clientdata, module, + "Can not read TIFF directory count"); + return 0; + } else { + _TIFFmemcpy(&dircount16, tif->tif_base + off, + sizeof(uint16)); + } + off += sizeof (uint16); + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabShort(&dircount16); + if (dircount16>4096) + { + TIFFErrorExt(tif->tif_clientdata, module, + "Sanity check on directory count failed, this is probably not a valid IFD offset"); + return 0; + } + dirsize = 12; + } + else + { + tmsize_t m; + uint64 dircount64; + m=off+sizeof(uint64); + if ((m<off)||(m<(tmsize_t)sizeof(uint64))||(m>tif->tif_size)) { + TIFFErrorExt(tif->tif_clientdata, module, + "Can not read TIFF directory count"); + return 0; + } else { + _TIFFmemcpy(&dircount64, tif->tif_base + off, + sizeof(uint64)); + } + off += sizeof (uint64); + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabLong8(&dircount64); + if (dircount64>4096) + { + TIFFErrorExt(tif->tif_clientdata, module, + "Sanity check on directory count failed, this is probably not a valid IFD offset"); + return 0; + } + dircount16 = (uint16)dircount64; + dirsize = 20; + } + if (dircount16 == 0 ) + { TIFFErrorExt(tif->tif_clientdata, module, - "%s: Can not read TIFF directory count", - tif->tif_name); + "Sanity check on directory count failed, zero tag directories not supported"); return 0; - } else { - _TIFFmemcpy(&dircount, tif->tif_base + off, - sizeof(uint16)); } - off += sizeof (uint16); - if (tif->tif_flags & TIFF_SWAB) - TIFFSwabShort(&dircount); - dir = (TIFFDirEntry *)_TIFFCheckMalloc(tif, dircount, - sizeof(TIFFDirEntry), + origdir = _TIFFCheckMalloc(tif, dircount16, + dirsize, "to read TIFF directory"); - if (dir == NULL) + if (origdir == NULL) return 0; - if (off + dircount * sizeof (TIFFDirEntry) > tif->tif_size) { + m=off+dircount16*dirsize; + if ((m<off)||(m<(tmsize_t)(dircount16*dirsize))||(m>tif->tif_size)) { TIFFErrorExt(tif->tif_clientdata, module, - "%s: Can not read TIFF directory", - tif->tif_name); - _TIFFfree(dir); + "Can not read TIFF directory"); + _TIFFfree(origdir); return 0; } else { - _TIFFmemcpy(dir, tif->tif_base + off, - dircount * sizeof(TIFFDirEntry)); + _TIFFmemcpy(origdir, tif->tif_base + off, + dircount16 * dirsize); } if (nextdiroff) { - off += dircount * sizeof (TIFFDirEntry); - if (off + sizeof (uint32) <= tif->tif_size) { - _TIFFmemcpy(nextdiroff, tif->tif_base + off, - sizeof (uint32)); + off += dircount16 * dirsize; + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + uint32 nextdiroff32; + m=off+sizeof(uint32); + if ((m<off)||(m<(tmsize_t)sizeof(uint32))||(m>tif->tif_size)) + nextdiroff32 = 0; + else + _TIFFmemcpy(&nextdiroff32, tif->tif_base + off, + sizeof (uint32)); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(&nextdiroff32); + *nextdiroff = nextdiroff32; + } + else + { + m=off+sizeof(uint64); + if ((m<off)||(m<(tmsize_t)sizeof(uint64))||(m>tif->tif_size)) + *nextdiroff = 0; + else + _TIFFmemcpy(nextdiroff, tif->tif_base + off, + sizeof (uint64)); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8(nextdiroff); } } } - if (nextdiroff && tif->tif_flags & TIFF_SWAB) - TIFFSwabLong(nextdiroff); - *pdir = dir; - return dircount; -} - -/* - * Fetch a contiguous directory item. - */ -static tsize_t -TIFFFetchData(TIFF* tif, TIFFDirEntry* dir, char* cp) -{ - uint32 w = TIFFDataWidth((TIFFDataType) dir->tdir_type); - /* - * FIXME: butecount should have tsize_t type, but for now libtiff - * defines tsize_t as a signed 32-bit integer and we are losing - * ability to read arrays larger than 2^31 bytes. So we are using - * uint32 instead of tsize_t here. - */ - uint32 cc = dir->tdir_count * w; - - /* Check for overflow. */ - if (!dir->tdir_count || !w || cc / w != dir->tdir_count) - goto bad; - - if (!isMapped(tif)) { - if (!SeekOK(tif, dir->tdir_offset)) - goto bad; - if (!ReadOK(tif, cp, cc)) - goto bad; - } else { - /* Check for overflow. */ - if (dir->tdir_offset + cc < dir->tdir_offset - || dir->tdir_offset + cc < cc - || dir->tdir_offset + cc > tif->tif_size) - goto bad; - _TIFFmemcpy(cp, tif->tif_base + dir->tdir_offset, cc); + dir = (TIFFDirEntry*)_TIFFCheckMalloc(tif, dircount16, + sizeof(TIFFDirEntry), + "to read TIFF directory"); + if (dir==0) + { + _TIFFfree(origdir); + return 0; } - if (tif->tif_flags & TIFF_SWAB) { - switch (dir->tdir_type) { - case TIFF_SHORT: - case TIFF_SSHORT: - TIFFSwabArrayOfShort((uint16*) cp, dir->tdir_count); - break; - case TIFF_LONG: - case TIFF_SLONG: - case TIFF_FLOAT: - TIFFSwabArrayOfLong((uint32*) cp, dir->tdir_count); - break; - case TIFF_RATIONAL: - case TIFF_SRATIONAL: - TIFFSwabArrayOfLong((uint32*) cp, 2*dir->tdir_count); - break; - case TIFF_DOUBLE: - TIFFSwabArrayOfDouble((double*) cp, dir->tdir_count); - break; + ma=(uint8*)origdir; + mb=dir; + for (n=0; n<dircount16; n++) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort((uint16*)ma); + mb->tdir_tag=*(uint16*)ma; + ma+=sizeof(uint16); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort((uint16*)ma); + mb->tdir_type=*(uint16*)ma; + ma+=sizeof(uint16); + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong((uint32*)ma); + mb->tdir_count=(uint64)(*(uint32*)ma); + ma+=sizeof(uint32); + *(uint32*)(&mb->tdir_offset)=*(uint32*)ma; + ma+=sizeof(uint32); } - } - return (cc); -bad: - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Error fetching data for field \"%s\"", - _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name); - return (tsize_t) 0; -} - -/* - * Fetch an ASCII item from the file. - */ -static tsize_t -TIFFFetchString(TIFF* tif, TIFFDirEntry* dir, char* cp) -{ - if (dir->tdir_count <= 4) { - uint32 l = dir->tdir_offset; - if (tif->tif_flags & TIFF_SWAB) - TIFFSwabLong(&l); - _TIFFmemcpy(cp, &l, dir->tdir_count); - return (1); - } - return (TIFFFetchData(tif, dir, cp)); -} - -/* - * Convert numerator+denominator to float. - */ -static int -cvtRational(TIFF* tif, TIFFDirEntry* dir, uint32 num, uint32 denom, float* rv) -{ - if (denom == 0) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "%s: Rational with zero denominator (num = %u)", - _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name, num); - return (0); - } else { - if (dir->tdir_type == TIFF_RATIONAL) - *rv = ((float)num / (float)denom); else - *rv = ((float)(int32)num / (float)(int32)denom); - return (1); - } -} - -/* - * Fetch a rational item from the file at offset off and return the value as a - * floating point number. - */ -static float -TIFFFetchRational(TIFF* tif, TIFFDirEntry* dir) -{ - uint32 l[2]; - float v; - - return (!TIFFFetchData(tif, dir, (char *)l) || - !cvtRational(tif, dir, l[0], l[1], &v) ? 1.0f : v); -} - -/* - * Fetch a single floating point value from the offset field and return it as - * a native float. - */ -static float -TIFFFetchFloat(TIFF* tif, TIFFDirEntry* dir) -{ - float v; - int32 l = TIFFExtractData(tif, dir->tdir_type, dir->tdir_offset); - _TIFFmemcpy(&v, &l, sizeof(float)); - TIFFCvtIEEEFloatToNative(tif, 1, &v); - return (v); -} - -/* - * Fetch an array of BYTE or SBYTE values. - */ -static int -TIFFFetchByteArray(TIFF* tif, TIFFDirEntry* dir, uint8* v) -{ - if (dir->tdir_count <= 4) { - /* - * Extract data from offset field. - */ - if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) { - if (dir->tdir_type == TIFF_SBYTE) - switch (dir->tdir_count) { - case 4: v[3] = dir->tdir_offset & 0xff; - case 3: v[2] = (dir->tdir_offset >> 8) & 0xff; - case 2: v[1] = (dir->tdir_offset >> 16) & 0xff; - case 1: v[0] = dir->tdir_offset >> 24; - } - else - switch (dir->tdir_count) { - case 4: v[3] = dir->tdir_offset & 0xff; - case 3: v[2] = (dir->tdir_offset >> 8) & 0xff; - case 2: v[1] = (dir->tdir_offset >> 16) & 0xff; - case 1: v[0] = dir->tdir_offset >> 24; - } - } else { - if (dir->tdir_type == TIFF_SBYTE) - switch (dir->tdir_count) { - case 4: v[3] = dir->tdir_offset >> 24; - case 3: v[2] = (dir->tdir_offset >> 16) & 0xff; - case 2: v[1] = (dir->tdir_offset >> 8) & 0xff; - case 1: v[0] = dir->tdir_offset & 0xff; - } - else - switch (dir->tdir_count) { - case 4: v[3] = dir->tdir_offset >> 24; - case 3: v[2] = (dir->tdir_offset >> 16) & 0xff; - case 2: v[1] = (dir->tdir_offset >> 8) & 0xff; - case 1: v[0] = dir->tdir_offset & 0xff; + { + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8((uint64*)ma); + mb->tdir_count=TIFFReadUInt64(ma); + ma+=sizeof(uint64); + mb->tdir_offset.toff_long8=TIFFReadUInt64(ma); + ma+=sizeof(uint64); } + mb++; } - return (1); - } else - return (TIFFFetchData(tif, dir, (char*) v) != 0); /* XXX */ + _TIFFfree(origdir); + *pdir = dir; + return dircount16; } /* - * Fetch an array of SHORT or SSHORT values. + * Fetch a tag that is not handled by special case code. */ static int -TIFFFetchShortArray(TIFF* tif, TIFFDirEntry* dir, uint16* v) +TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp, int recover) { - if (dir->tdir_count <= 2) { - if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) { - switch (dir->tdir_count) { - case 2: v[1] = (uint16) (dir->tdir_offset & 0xffff); - case 1: v[0] = (uint16) (dir->tdir_offset >> 16); + static const char module[] = "TIFFFetchNormalTag"; + enum TIFFReadDirEntryErr err; + uint32 fii; + const TIFFField* fip = NULL; + TIFFReadDirectoryFindFieldInfo(tif,dp->tdir_tag,&fii); + if( fii == FAILED_FII ) + { + TIFFErrorExt(tif->tif_clientdata, "TIFFFetchNormalTag", + "No definition found for tag %d", + dp->tdir_tag); + return 0; + } + fip=tif->tif_fields[fii]; + assert(fip->set_field_type!=TIFF_SETGET_OTHER); /* if so, we shouldn't arrive here but deal with this in specialized code */ + assert(fip->set_field_type!=TIFF_SETGET_INT); /* if so, we shouldn't arrive here as this is only the case for pseudo-tags */ + err=TIFFReadDirEntryErrOk; + switch (fip->set_field_type) + { + case TIFF_SETGET_UNDEFINED: + break; + case TIFF_SETGET_ASCII: + { + uint8* data; + assert(fip->field_passcount==0); + err=TIFFReadDirEntryByteArray(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + uint8* ma; + uint32 mb; + int n; + ma=data; + mb=0; + while (mb<(uint32)dp->tdir_count) + { + if (*ma==0) + break; + ma++; + mb++; + } + if (mb+1<(uint32)dp->tdir_count) + TIFFWarningExt(tif->tif_clientdata,module,"ASCII value for tag \"%s\" contains null byte in value; value incorrectly truncated during reading due to implementation limitations",fip->field_name); + else if (mb+1>(uint32)dp->tdir_count) + { + uint8* o; + TIFFWarningExt(tif->tif_clientdata,module,"ASCII value for tag \"%s\" does not end in null byte",fip->field_name); + if ((uint32)dp->tdir_count+1!=dp->tdir_count+1) + o=NULL; + else + o=_TIFFmalloc((uint32)dp->tdir_count+1); + if (o==NULL) + { + if (data!=NULL) + _TIFFfree(data); + return(0); + } + _TIFFmemcpy(o,data,(uint32)dp->tdir_count); + o[(uint32)dp->tdir_count]=0; + if (data!=0) + _TIFFfree(data); + data=o; + } + n=TIFFSetField(tif,dp->tdir_tag,data); + if (data!=0) + _TIFFfree(data); + if (!n) + return(0); + } } - } else { - switch (dir->tdir_count) { - case 2: v[1] = (uint16) (dir->tdir_offset >> 16); - case 1: v[0] = (uint16) (dir->tdir_offset & 0xffff); + break; + case TIFF_SETGET_UINT8: + { + uint8 data=0; + assert(fip->field_readcount==1); + assert(fip->field_passcount==0); + err=TIFFReadDirEntryByte(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + if (!TIFFSetField(tif,dp->tdir_tag,data)) + return(0); + } } - } - return (1); - } else - return (TIFFFetchData(tif, dir, (char *)v) != 0); -} - -/* - * Fetch a pair of SHORT or BYTE values. Some tags may have either BYTE - * or SHORT type and this function works with both ones. - */ -static int -TIFFFetchShortPair(TIFF* tif, TIFFDirEntry* dir) -{ - /* - * Prevent overflowing the v stack arrays below by performing a sanity - * check on tdir_count, this should never be greater than two. - */ - if (dir->tdir_count > 2) { - TIFFWarningExt(tif->tif_clientdata, tif->tif_name, - "unexpected count for field \"%s\", %u, expected 2; ignored", - _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name, - dir->tdir_count); - return 0; - } - - switch (dir->tdir_type) { - case TIFF_BYTE: - case TIFF_SBYTE: + break; + case TIFF_SETGET_UINT16: { - uint8 v[4]; - return TIFFFetchByteArray(tif, dir, v) - && TIFFSetField(tif, dir->tdir_tag, v[0], v[1]); + uint16 data; + assert(fip->field_readcount==1); + assert(fip->field_passcount==0); + err=TIFFReadDirEntryShort(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + if (!TIFFSetField(tif,dp->tdir_tag,data)) + return(0); + } } - case TIFF_SHORT: - case TIFF_SSHORT: + break; + case TIFF_SETGET_UINT32: { - uint16 v[2]; - return TIFFFetchShortArray(tif, dir, v) - && TIFFSetField(tif, dir->tdir_tag, v[0], v[1]); + uint32 data; + assert(fip->field_readcount==1); + assert(fip->field_passcount==0); + err=TIFFReadDirEntryLong(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + if (!TIFFSetField(tif,dp->tdir_tag,data)) + return(0); + } } - default: - return 0; - } -} - -/* - * Fetch an array of LONG or SLONG values. - */ -static int -TIFFFetchLongArray(TIFF* tif, TIFFDirEntry* dir, uint32* v) -{ - if (dir->tdir_count == 1) { - v[0] = dir->tdir_offset; - return (1); - } else - return (TIFFFetchData(tif, dir, (char*) v) != 0); -} - -/* - * Fetch an array of RATIONAL or SRATIONAL values. - */ -static int -TIFFFetchRationalArray(TIFF* tif, TIFFDirEntry* dir, float* v) -{ - int ok = 0; - uint32* l; - - l = (uint32*)_TIFFCheckMalloc(tif, - dir->tdir_count, TIFFDataWidth((TIFFDataType) dir->tdir_type), - "to fetch array of rationals"); - if (l) { - if (TIFFFetchData(tif, dir, (char *)l)) { - uint32 i; - for (i = 0; i < dir->tdir_count; i++) { - ok = cvtRational(tif, dir, - l[2*i+0], l[2*i+1], &v[i]); - if (!ok) - break; + break; + case TIFF_SETGET_UINT64: + { + uint64 data; + assert(fip->field_readcount==1); + assert(fip->field_passcount==0); + err=TIFFReadDirEntryLong8(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + if (!TIFFSetField(tif,dp->tdir_tag,data)) + return(0); + } } - } - _TIFFfree((char *)l); - } - return (ok); -} - -/* - * Fetch an array of FLOAT values. - */ -static int -TIFFFetchFloatArray(TIFF* tif, TIFFDirEntry* dir, float* v) -{ - - if (dir->tdir_count == 1) { - union - { - float f; - uint32 i; - } float_union; - - float_union.i=dir->tdir_offset; - v[0]=float_union.f; - TIFFCvtIEEEFloatToNative(tif, dir->tdir_count, v); - return (1); - } else if (TIFFFetchData(tif, dir, (char*) v)) { - TIFFCvtIEEEFloatToNative(tif, dir->tdir_count, v); - return (1); - } else - return (0); -} - -/* - * Fetch an array of DOUBLE values. - */ -static int -TIFFFetchDoubleArray(TIFF* tif, TIFFDirEntry* dir, double* v) -{ - if (TIFFFetchData(tif, dir, (char*) v)) { - TIFFCvtIEEEDoubleToNative(tif, dir->tdir_count, v); - return (1); - } else - return (0); -} - -/* - * Fetch an array of ANY values. The actual values are returned as doubles - * which should be able hold all the types. Yes, there really should be an - * tany_t to avoid this potential non-portability ... Note in particular that - * we assume that the double return value vector is large enough to read in - * any fundamental type. We use that vector as a buffer to read in the base - * type vector and then convert it in place to double (from end to front of - * course). - */ -static int -TIFFFetchAnyArray(TIFF* tif, TIFFDirEntry* dir, double* v) -{ - int i; - - switch (dir->tdir_type) { - case TIFF_BYTE: - case TIFF_SBYTE: - if (!TIFFFetchByteArray(tif, dir, (uint8*) v)) - return (0); - if (dir->tdir_type == TIFF_BYTE) { - uint8* vp = (uint8*) v; - for (i = dir->tdir_count-1; i >= 0; i--) - v[i] = vp[i]; - } else { - int8* vp = (int8*) v; - for (i = dir->tdir_count-1; i >= 0; i--) - v[i] = vp[i]; - } - break; - case TIFF_SHORT: - case TIFF_SSHORT: - if (!TIFFFetchShortArray(tif, dir, (uint16*) v)) - return (0); - if (dir->tdir_type == TIFF_SHORT) { - uint16* vp = (uint16*) v; - for (i = dir->tdir_count-1; i >= 0; i--) - v[i] = vp[i]; - } else { - int16* vp = (int16*) v; - for (i = dir->tdir_count-1; i >= 0; i--) - v[i] = vp[i]; - } - break; - case TIFF_LONG: - case TIFF_SLONG: - if (!TIFFFetchLongArray(tif, dir, (uint32*) v)) - return (0); - if (dir->tdir_type == TIFF_LONG) { - uint32* vp = (uint32*) v; - for (i = dir->tdir_count-1; i >= 0; i--) - v[i] = vp[i]; - } else { - int32* vp = (int32*) v; - for (i = dir->tdir_count-1; i >= 0; i--) - v[i] = vp[i]; - } - break; - case TIFF_RATIONAL: - case TIFF_SRATIONAL: - if (!TIFFFetchRationalArray(tif, dir, (float*) v)) - return (0); - { float* vp = (float*) v; - for (i = dir->tdir_count-1; i >= 0; i--) - v[i] = vp[i]; - } - break; - case TIFF_FLOAT: - if (!TIFFFetchFloatArray(tif, dir, (float*) v)) - return (0); - { float* vp = (float*) v; - for (i = dir->tdir_count-1; i >= 0; i--) - v[i] = vp[i]; - } - break; - case TIFF_DOUBLE: - return (TIFFFetchDoubleArray(tif, dir, (double*) v)); - default: - /* TIFF_NOTYPE */ - /* TIFF_ASCII */ - /* TIFF_UNDEFINED */ - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "cannot read TIFF_ANY type %d for field \"%s\"", - dir->tdir_type, - _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name); - return (0); - } - return (1); -} - -/* - * Fetch a tag that is not handled by special case code. - */ -static int -TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp) -{ - static const char mesg[] = "to fetch tag value"; - int ok = 0; - const TIFFFieldInfo* fip = _TIFFFieldWithTag(tif, dp->tdir_tag); - - if (dp->tdir_count > 1) { /* array of values */ - char* cp = NULL; - - switch (dp->tdir_type) { - case TIFF_BYTE: - case TIFF_SBYTE: - cp = (char *)_TIFFCheckMalloc(tif, - dp->tdir_count, sizeof (uint8), mesg); - ok = cp && TIFFFetchByteArray(tif, dp, (uint8*) cp); break; - case TIFF_SHORT: - case TIFF_SSHORT: - cp = (char *)_TIFFCheckMalloc(tif, - dp->tdir_count, sizeof (uint16), mesg); - ok = cp && TIFFFetchShortArray(tif, dp, (uint16*) cp); + case TIFF_SETGET_FLOAT: + { + float data; + assert(fip->field_readcount==1); + assert(fip->field_passcount==0); + err=TIFFReadDirEntryFloat(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + if (!TIFFSetField(tif,dp->tdir_tag,data)) + return(0); + } + } break; - case TIFF_LONG: - case TIFF_SLONG: - cp = (char *)_TIFFCheckMalloc(tif, - dp->tdir_count, sizeof (uint32), mesg); - ok = cp && TIFFFetchLongArray(tif, dp, (uint32*) cp); + case TIFF_SETGET_DOUBLE: + { + double data; + assert(fip->field_readcount==1); + assert(fip->field_passcount==0); + err=TIFFReadDirEntryDouble(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + if (!TIFFSetField(tif,dp->tdir_tag,data)) + return(0); + } + } break; - case TIFF_RATIONAL: - case TIFF_SRATIONAL: - cp = (char *)_TIFFCheckMalloc(tif, - dp->tdir_count, sizeof (float), mesg); - ok = cp && TIFFFetchRationalArray(tif, dp, (float*) cp); + case TIFF_SETGET_IFD8: + { + uint64 data; + assert(fip->field_readcount==1); + assert(fip->field_passcount==0); + err=TIFFReadDirEntryIfd8(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + if (!TIFFSetField(tif,dp->tdir_tag,data)) + return(0); + } + } break; - case TIFF_FLOAT: - cp = (char *)_TIFFCheckMalloc(tif, - dp->tdir_count, sizeof (float), mesg); - ok = cp && TIFFFetchFloatArray(tif, dp, (float*) cp); + case TIFF_SETGET_UINT16_PAIR: + { + uint16* data; + assert(fip->field_readcount==2); + assert(fip->field_passcount==0); + if (dp->tdir_count!=2) { + TIFFWarningExt(tif->tif_clientdata,module, + "incorrect count for field \"%s\", expected 2, got %d", + fip->field_name,(int)dp->tdir_count); + return(0); + } + err=TIFFReadDirEntryShortArray(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,data[0],data[1]); + _TIFFfree(data); + if (!m) + return(0); + } + } break; - case TIFF_DOUBLE: - cp = (char *)_TIFFCheckMalloc(tif, - dp->tdir_count, sizeof (double), mesg); - ok = cp && TIFFFetchDoubleArray(tif, dp, (double*) cp); + case TIFF_SETGET_C0_UINT8: + { + uint8* data; + assert(fip->field_readcount>=1); + assert(fip->field_passcount==0); + if (dp->tdir_count!=(uint64)fip->field_readcount) { + TIFFWarningExt(tif->tif_clientdata,module, + "incorrect count for field \"%s\", expected %d, got %d", + fip->field_name,(int) fip->field_readcount, (int)dp->tdir_count); + return 0; + } + else + { + err=TIFFReadDirEntryByteArray(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,data); + if (data!=0) + _TIFFfree(data); + if (!m) + return(0); + } + } + } break; - case TIFF_ASCII: - case TIFF_UNDEFINED: /* bit of a cheat... */ - /* - * Some vendors write strings w/o the trailing - * NULL byte, so always append one just in case. - */ - cp = (char *)_TIFFCheckMalloc(tif, dp->tdir_count + 1, - 1, mesg); - if( (ok = (cp && TIFFFetchString(tif, dp, cp))) != 0 ) - cp[dp->tdir_count] = '\0'; /* XXX */ + case TIFF_SETGET_C0_UINT16: + { + uint16* data; + assert(fip->field_readcount>=1); + assert(fip->field_passcount==0); + if (dp->tdir_count!=(uint64)fip->field_readcount) + /* corrupt file */; + else + { + err=TIFFReadDirEntryShortArray(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,data); + if (data!=0) + _TIFFfree(data); + if (!m) + return(0); + } + } + } break; - } - if (ok) { - ok = (fip->field_passcount ? - TIFFSetField(tif, dp->tdir_tag, dp->tdir_count, cp) - : TIFFSetField(tif, dp->tdir_tag, cp)); - } - if (cp != NULL) - _TIFFfree(cp); - } else if (CheckDirCount(tif, dp, 1)) { /* singleton value */ - switch (dp->tdir_type) { - case TIFF_BYTE: - case TIFF_SBYTE: - case TIFF_SHORT: - case TIFF_SSHORT: - /* - * If the tag is also acceptable as a LONG or SLONG - * then TIFFSetField will expect an uint32 parameter - * passed to it (through varargs). Thus, for machines - * where sizeof (int) != sizeof (uint32) we must do - * a careful check here. It's hard to say if this - * is worth optimizing. - * - * NB: We use TIFFFieldWithTag here knowing that - * it returns us the first entry in the table - * for the tag and that that entry is for the - * widest potential data type the tag may have. - */ - { TIFFDataType type = fip->field_type; - if (type != TIFF_LONG && type != TIFF_SLONG) { - uint16 v = (uint16) - TIFFExtractData(tif, dp->tdir_type, dp->tdir_offset); - ok = (fip->field_passcount ? - TIFFSetField(tif, dp->tdir_tag, 1, &v) - : TIFFSetField(tif, dp->tdir_tag, v)); - break; - } + case TIFF_SETGET_C0_UINT32: + { + uint32* data; + assert(fip->field_readcount>=1); + assert(fip->field_passcount==0); + if (dp->tdir_count!=(uint64)fip->field_readcount) + /* corrupt file */; + else + { + err=TIFFReadDirEntryLongArray(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,data); + if (data!=0) + _TIFFfree(data); + if (!m) + return(0); + } + } } - /* fall thru... */ - case TIFF_LONG: - case TIFF_SLONG: - { uint32 v32 = - TIFFExtractData(tif, dp->tdir_type, dp->tdir_offset); - ok = (fip->field_passcount ? - TIFFSetField(tif, dp->tdir_tag, 1, &v32) - : TIFFSetField(tif, dp->tdir_tag, v32)); + break; + case TIFF_SETGET_C0_FLOAT: + { + float* data; + assert(fip->field_readcount>=1); + assert(fip->field_passcount==0); + if (dp->tdir_count!=(uint64)fip->field_readcount) + /* corrupt file */; + else + { + err=TIFFReadDirEntryFloatArray(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,data); + if (data!=0) + _TIFFfree(data); + if (!m) + return(0); + } + } } break; - case TIFF_RATIONAL: - case TIFF_SRATIONAL: - case TIFF_FLOAT: - { float v = (dp->tdir_type == TIFF_FLOAT ? - TIFFFetchFloat(tif, dp) - : TIFFFetchRational(tif, dp)); - ok = (fip->field_passcount ? - TIFFSetField(tif, dp->tdir_tag, 1, &v) - : TIFFSetField(tif, dp->tdir_tag, v)); + case TIFF_SETGET_C16_ASCII: + { + uint8* data; + assert(fip->field_readcount==TIFF_VARIABLE); + assert(fip->field_passcount==1); + if (dp->tdir_count>0xFFFF) + err=TIFFReadDirEntryErrCount; + else + { + err=TIFFReadDirEntryByteArray(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,(uint16)(dp->tdir_count),data); + if (data!=0) + _TIFFfree(data); + if (!m) + return(0); + } + } } break; - case TIFF_DOUBLE: - { double v; - ok = (TIFFFetchDoubleArray(tif, dp, &v) && - (fip->field_passcount ? - TIFFSetField(tif, dp->tdir_tag, 1, &v) - : TIFFSetField(tif, dp->tdir_tag, v)) - ); + case TIFF_SETGET_C16_UINT8: + { + uint8* data; + assert(fip->field_readcount==TIFF_VARIABLE); + assert(fip->field_passcount==1); + if (dp->tdir_count>0xFFFF) + err=TIFFReadDirEntryErrCount; + else + { + err=TIFFReadDirEntryByteArray(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,(uint16)(dp->tdir_count),data); + if (data!=0) + _TIFFfree(data); + if (!m) + return(0); + } + } } break; - case TIFF_ASCII: - case TIFF_UNDEFINED: /* bit of a cheat... */ - { char c[2]; - if( (ok = (TIFFFetchString(tif, dp, c) != 0)) != 0 ) { - c[1] = '\0'; /* XXX paranoid */ - ok = (fip->field_passcount ? - TIFFSetField(tif, dp->tdir_tag, 1, c) - : TIFFSetField(tif, dp->tdir_tag, c)); - } + case TIFF_SETGET_C16_UINT16: + { + uint16* data; + assert(fip->field_readcount==TIFF_VARIABLE); + assert(fip->field_passcount==1); + if (dp->tdir_count>0xFFFF) + err=TIFFReadDirEntryErrCount; + else + { + err=TIFFReadDirEntryShortArray(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,(uint16)(dp->tdir_count),data); + if (data!=0) + _TIFFfree(data); + if (!m) + return(0); + } + } } break; - } + case TIFF_SETGET_C16_UINT32: + { + uint32* data; + assert(fip->field_readcount==TIFF_VARIABLE); + assert(fip->field_passcount==1); + if (dp->tdir_count>0xFFFF) + err=TIFFReadDirEntryErrCount; + else + { + err=TIFFReadDirEntryLongArray(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,(uint16)(dp->tdir_count),data); + if (data!=0) + _TIFFfree(data); + if (!m) + return(0); + } + } + } + break; + case TIFF_SETGET_C16_UINT64: + { + uint64* data; + assert(fip->field_readcount==TIFF_VARIABLE); + assert(fip->field_passcount==1); + if (dp->tdir_count>0xFFFF) + err=TIFFReadDirEntryErrCount; + else + { + err=TIFFReadDirEntryLong8Array(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,(uint16)(dp->tdir_count),data); + if (data!=0) + _TIFFfree(data); + if (!m) + return(0); + } + } + } + break; + case TIFF_SETGET_C16_FLOAT: + { + float* data; + assert(fip->field_readcount==TIFF_VARIABLE); + assert(fip->field_passcount==1); + if (dp->tdir_count>0xFFFF) + err=TIFFReadDirEntryErrCount; + else + { + err=TIFFReadDirEntryFloatArray(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,(uint16)(dp->tdir_count),data); + if (data!=0) + _TIFFfree(data); + if (!m) + return(0); + } + } + } + break; + case TIFF_SETGET_C16_DOUBLE: + { + double* data; + assert(fip->field_readcount==TIFF_VARIABLE); + assert(fip->field_passcount==1); + if (dp->tdir_count>0xFFFF) + err=TIFFReadDirEntryErrCount; + else + { + err=TIFFReadDirEntryDoubleArray(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,(uint16)(dp->tdir_count),data); + if (data!=0) + _TIFFfree(data); + if (!m) + return(0); + } + } + } + break; + case TIFF_SETGET_C16_IFD8: + { + uint64* data; + assert(fip->field_readcount==TIFF_VARIABLE); + assert(fip->field_passcount==1); + if (dp->tdir_count>0xFFFF) + err=TIFFReadDirEntryErrCount; + else + { + err=TIFFReadDirEntryIfd8Array(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,(uint16)(dp->tdir_count),data); + if (data!=0) + _TIFFfree(data); + if (!m) + return(0); + } + } + } + break; + case TIFF_SETGET_C32_ASCII: + { + uint8* data; + assert(fip->field_readcount==TIFF_VARIABLE2); + assert(fip->field_passcount==1); + err=TIFFReadDirEntryByteArray(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,(uint32)(dp->tdir_count),data); + if (data!=0) + _TIFFfree(data); + if (!m) + return(0); + } + } + break; + case TIFF_SETGET_C32_UINT8: + { + uint8* data; + assert(fip->field_readcount==TIFF_VARIABLE2); + assert(fip->field_passcount==1); + err=TIFFReadDirEntryByteArray(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,(uint32)(dp->tdir_count),data); + if (data!=0) + _TIFFfree(data); + if (!m) + return(0); + } + } + break; + case TIFF_SETGET_C32_SINT8: + { + int8* data = NULL; + assert(fip->field_readcount==TIFF_VARIABLE2); + assert(fip->field_passcount==1); + err=TIFFReadDirEntrySbyteArray(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,(uint32)(dp->tdir_count),data); + if (data!=0) + _TIFFfree(data); + if (!m) + return(0); + } + } + break; + case TIFF_SETGET_C32_UINT16: + { + uint16* data; + assert(fip->field_readcount==TIFF_VARIABLE2); + assert(fip->field_passcount==1); + err=TIFFReadDirEntryShortArray(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,(uint32)(dp->tdir_count),data); + if (data!=0) + _TIFFfree(data); + if (!m) + return(0); + } + } + break; + case TIFF_SETGET_C32_SINT16: + { + int16* data = NULL; + assert(fip->field_readcount==TIFF_VARIABLE2); + assert(fip->field_passcount==1); + err=TIFFReadDirEntrySshortArray(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,(uint32)(dp->tdir_count),data); + if (data!=0) + _TIFFfree(data); + if (!m) + return(0); + } + } + break; + case TIFF_SETGET_C32_UINT32: + { + uint32* data; + assert(fip->field_readcount==TIFF_VARIABLE2); + assert(fip->field_passcount==1); + err=TIFFReadDirEntryLongArray(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,(uint32)(dp->tdir_count),data); + if (data!=0) + _TIFFfree(data); + if (!m) + return(0); + } + } + break; + case TIFF_SETGET_C32_SINT32: + { + int32* data = NULL; + assert(fip->field_readcount==TIFF_VARIABLE2); + assert(fip->field_passcount==1); + err=TIFFReadDirEntrySlongArray(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,(uint32)(dp->tdir_count),data); + if (data!=0) + _TIFFfree(data); + if (!m) + return(0); + } + } + break; + case TIFF_SETGET_C32_UINT64: + { + uint64* data; + assert(fip->field_readcount==TIFF_VARIABLE2); + assert(fip->field_passcount==1); + err=TIFFReadDirEntryLong8Array(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,(uint32)(dp->tdir_count),data); + if (data!=0) + _TIFFfree(data); + if (!m) + return(0); + } + } + break; + case TIFF_SETGET_C32_SINT64: + { + int64* data = NULL; + assert(fip->field_readcount==TIFF_VARIABLE2); + assert(fip->field_passcount==1); + err=TIFFReadDirEntrySlong8Array(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,(uint32)(dp->tdir_count),data); + if (data!=0) + _TIFFfree(data); + if (!m) + return(0); + } + } + break; + case TIFF_SETGET_C32_FLOAT: + { + float* data; + assert(fip->field_readcount==TIFF_VARIABLE2); + assert(fip->field_passcount==1); + err=TIFFReadDirEntryFloatArray(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,(uint32)(dp->tdir_count),data); + if (data!=0) + _TIFFfree(data); + if (!m) + return(0); + } + } + break; + case TIFF_SETGET_C32_DOUBLE: + { + double* data; + assert(fip->field_readcount==TIFF_VARIABLE2); + assert(fip->field_passcount==1); + err=TIFFReadDirEntryDoubleArray(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,(uint32)(dp->tdir_count),data); + if (data!=0) + _TIFFfree(data); + if (!m) + return(0); + } + } + break; + case TIFF_SETGET_C32_IFD8: + { + uint64* data; + assert(fip->field_readcount==TIFF_VARIABLE2); + assert(fip->field_passcount==1); + err=TIFFReadDirEntryIfd8Array(tif,dp,&data); + if (err==TIFFReadDirEntryErrOk) + { + int m; + m=TIFFSetField(tif,dp->tdir_tag,(uint32)(dp->tdir_count),data); + if (data!=0) + _TIFFfree(data); + if (!m) + return(0); + } + } + break; + default: + assert(0); /* we should never get here */ + break; } - return (ok); -} - -#define NITEMS(x) (sizeof (x) / sizeof (x[0])) -/* - * Fetch samples/pixel short values for - * the specified tag and verify that - * all values are the same. - */ -static int -TIFFFetchPerSampleShorts(TIFF* tif, TIFFDirEntry* dir, uint16* pl) -{ - uint16 samples = tif->tif_dir.td_samplesperpixel; - int status = 0; - - if (CheckDirCount(tif, dir, (uint32) samples)) { - uint16 buf[10]; - uint16* v = buf; - - if (dir->tdir_count > NITEMS(buf)) - v = (uint16*) _TIFFCheckMalloc(tif, dir->tdir_count, sizeof(uint16), - "to fetch per-sample values"); - if (v && TIFFFetchShortArray(tif, dir, v)) { - uint16 i; - int check_count = dir->tdir_count; - if( samples < check_count ) - check_count = samples; - - for (i = 1; i < check_count; i++) - if (v[i] != v[0]) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Cannot handle different per-sample values for field \"%s\"", - _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name); - goto bad; - } - *pl = v[0]; - status = 1; - } - bad: - if (v && v != buf) - _TIFFfree(v); - } - return (status); -} - -/* - * Fetch samples/pixel long values for - * the specified tag and verify that - * all values are the same. - */ -static int -TIFFFetchPerSampleLongs(TIFF* tif, TIFFDirEntry* dir, uint32* pl) -{ - uint16 samples = tif->tif_dir.td_samplesperpixel; - int status = 0; - - if (CheckDirCount(tif, dir, (uint32) samples)) { - uint32 buf[10]; - uint32* v = buf; - - if (dir->tdir_count > NITEMS(buf)) - v = (uint32*) _TIFFCheckMalloc(tif, dir->tdir_count, sizeof(uint32), - "to fetch per-sample values"); - if (v && TIFFFetchLongArray(tif, dir, v)) { - uint16 i; - int check_count = dir->tdir_count; - - if( samples < check_count ) - check_count = samples; - for (i = 1; i < check_count; i++) - if (v[i] != v[0]) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Cannot handle different per-sample values for field \"%s\"", - _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name); - goto bad; - } - *pl = v[0]; - status = 1; - } - bad: - if (v && v != buf) - _TIFFfree(v); - } - return (status); -} - -/* - * Fetch samples/pixel ANY values for the specified tag and verify that all - * values are the same. - */ -static int -TIFFFetchPerSampleAnys(TIFF* tif, TIFFDirEntry* dir, double* pl) -{ - uint16 samples = tif->tif_dir.td_samplesperpixel; - int status = 0; - - if (CheckDirCount(tif, dir, (uint32) samples)) { - double buf[10]; - double* v = buf; - - if (dir->tdir_count > NITEMS(buf)) - v = (double*) _TIFFCheckMalloc(tif, dir->tdir_count, sizeof (double), - "to fetch per-sample values"); - if (v && TIFFFetchAnyArray(tif, dir, v)) { - uint16 i; - int check_count = dir->tdir_count; - if( samples < check_count ) - check_count = samples; - - for (i = 1; i < check_count; i++) - if (v[i] != v[0]) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Cannot handle different per-sample values for field \"%s\"", - _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name); - goto bad; - } - *pl = v[0]; - status = 1; - } - bad: - if (v && v != buf) - _TIFFfree(v); - } - return (status); + if (err!=TIFFReadDirEntryErrOk) + { + TIFFReadDirEntryOutputErr(tif,err,module,fip ? fip->field_name : "unknown tagname",recover); + return(0); + } + return(1); } -#undef NITEMS /* * Fetch a set of offsets or lengths. * While this routine says "strips", in fact it's also used for tiles. */ static int -TIFFFetchStripThing(TIFF* tif, TIFFDirEntry* dir, long nstrips, uint32** lpp) +TIFFFetchStripThing(TIFF* tif, TIFFDirEntry* dir, uint32 nstrips, uint64** lpp) { - register uint32* lp; - int status; - - CheckDirCount(tif, dir, (uint32) nstrips); - - /* - * Allocate space for strip information. - */ - if (*lpp == NULL && - (*lpp = (uint32 *)_TIFFCheckMalloc(tif, - nstrips, sizeof (uint32), "for strip array")) == NULL) - return (0); - lp = *lpp; - _TIFFmemset( lp, 0, sizeof(uint32) * nstrips ); - - if (dir->tdir_type == (int)TIFF_SHORT) { - /* - * Handle uint16->uint32 expansion. - */ - uint16* dp = (uint16*) _TIFFCheckMalloc(tif, - dir->tdir_count, sizeof (uint16), "to fetch strip tag"); - if (dp == NULL) - return (0); - if( (status = TIFFFetchShortArray(tif, dir, dp)) != 0 ) { - int i; - - for( i = 0; i < nstrips && i < (int) dir->tdir_count; i++ ) - { - lp[i] = dp[i]; - } + static const char module[] = "TIFFFetchStripThing"; + enum TIFFReadDirEntryErr err; + uint64* data; + err=TIFFReadDirEntryLong8Array(tif,dir,&data); + if (err!=TIFFReadDirEntryErrOk) + { + const TIFFField* fip = TIFFFieldWithTag(tif,dir->tdir_tag); + TIFFReadDirEntryOutputErr(tif,err,module,fip ? fip->field_name : "unknown tagname",0); + return(0); + } + if (dir->tdir_count!=(uint64)nstrips) + { + uint64* resizeddata; + resizeddata=(uint64*)_TIFFCheckMalloc(tif,nstrips,sizeof(uint64),"for strip array"); + if (resizeddata==0) { + _TIFFfree(data); + return(0); } - _TIFFfree((char*) dp); - - } else if( nstrips != (int) dir->tdir_count ) { - /* Special case to correct length */ - - uint32* dp = (uint32*) _TIFFCheckMalloc(tif, - dir->tdir_count, sizeof (uint32), "to fetch strip tag"); - if (dp == NULL) - return (0); - - status = TIFFFetchLongArray(tif, dir, dp); - if( status != 0 ) { - int i; - - for( i = 0; i < nstrips && i < (int) dir->tdir_count; i++ ) - { - lp[i] = dp[i]; - } - } - - _TIFFfree( (char *) dp ); - } else - status = TIFFFetchLongArray(tif, dir, lp); - - return (status); -} - -/* - * Fetch and set the RefBlackWhite tag. - */ -static int -TIFFFetchRefBlackWhite(TIFF* tif, TIFFDirEntry* dir) -{ - static const char mesg[] = "for \"ReferenceBlackWhite\" array"; - char* cp; - int ok; - - if (dir->tdir_type == TIFF_RATIONAL) - return (TIFFFetchNormalTag(tif, dir)); - /* - * Handle LONG's for backward compatibility. - */ - cp = (char *)_TIFFCheckMalloc(tif, dir->tdir_count, - sizeof (uint32), mesg); - if( (ok = (cp && TIFFFetchLongArray(tif, dir, (uint32*) cp))) != 0) { - float* fp = (float*) - _TIFFCheckMalloc(tif, dir->tdir_count, sizeof (float), mesg); - if( (ok = (fp != NULL)) != 0 ) { - uint32 i; - for (i = 0; i < dir->tdir_count; i++) - fp[i] = (float)((uint32*) cp)[i]; - ok = TIFFSetField(tif, dir->tdir_tag, fp); - _TIFFfree((char*) fp); + if (dir->tdir_count<(uint64)nstrips) + { + _TIFFmemcpy(resizeddata,data,(uint32)dir->tdir_count*sizeof(uint64)); + _TIFFmemset(resizeddata+(uint32)dir->tdir_count,0,(nstrips-(uint32)dir->tdir_count)*sizeof(uint64)); } + else + _TIFFmemcpy(resizeddata,data,nstrips*sizeof(uint64)); + _TIFFfree(data); + data=resizeddata; } - if (cp) - _TIFFfree(cp); - return (ok); + *lpp=data; + return(1); } /* @@ -1915,22 +5406,56 @@ TIFFFetchRefBlackWhite(TIFF* tif, TIFFDirEntry* dir) static int TIFFFetchSubjectDistance(TIFF* tif, TIFFDirEntry* dir) { - uint32 l[2]; - float v; - int ok = 0; - - if (TIFFFetchData(tif, dir, (char *)l) - && cvtRational(tif, dir, l[0], l[1], &v)) { - /* - * XXX: Numerator 0xFFFFFFFF means that we have infinite - * distance. Indicate that with a negative floating point - * SubjectDistance value. - */ - ok = TIFFSetField(tif, dir->tdir_tag, - (l[0] != 0xFFFFFFFF) ? v : -v); + static const char module[] = "TIFFFetchSubjectDistance"; + enum TIFFReadDirEntryErr err; + UInt64Aligned_t m; + m.l=0; + assert(sizeof(double)==8); + assert(sizeof(uint64)==8); + assert(sizeof(uint32)==4); + if (dir->tdir_count!=1) + err=TIFFReadDirEntryErrCount; + else if (dir->tdir_type!=TIFF_RATIONAL) + err=TIFFReadDirEntryErrType; + else + { + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + uint32 offset; + offset=*(uint32*)(&dir->tdir_offset); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(&offset); + err=TIFFReadDirEntryData(tif,offset,8,m.i); + } + else + { + m.l=dir->tdir_offset.toff_long8; + err=TIFFReadDirEntryErrOk; + } + } + if (err==TIFFReadDirEntryErrOk) + { + double n; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfLong(m.i,2); + if (m.i[0]==0) + n=0.0; + else if (m.i[0]==0xFFFFFFFF) + /* + * XXX: Numerator 0xFFFFFFFF means that we have infinite + * distance. Indicate that with a negative floating point + * SubjectDistance value. + */ + n=-1.0; + else + n=(double)m.i[0]/(double)m.i[1]; + return(TIFFSetField(tif,dir->tdir_tag,n)); + } + else + { + TIFFReadDirEntryOutputErr(tif,err,module,"SubjectDistance",TRUE); + return(0); } - - return ok; } /* @@ -1943,42 +5468,59 @@ static void ChopUpSingleUncompressedStrip(TIFF* tif) { register TIFFDirectory *td = &tif->tif_dir; - uint32 bytecount = td->td_stripbytecount[0]; - uint32 offset = td->td_stripoffset[0]; - tsize_t rowbytes = TIFFVTileSize(tif, 1), stripbytes; - tstrip_t strip, nstrips, rowsperstrip; - uint32* newcounts; - uint32* newoffsets; + uint64 bytecount; + uint64 offset; + uint32 rowblock; + uint64 rowblockbytes; + uint64 stripbytes; + uint32 strip; + uint64 nstrips64; + uint32 nstrips32; + uint32 rowsperstrip; + uint64* newcounts; + uint64* newoffsets; + bytecount = td->td_stripbytecount[0]; + offset = td->td_stripoffset[0]; + assert(td->td_planarconfig == PLANARCONFIG_CONTIG); + if ((td->td_photometric == PHOTOMETRIC_YCBCR)&& + (!isUpSampled(tif))) + rowblock = td->td_ycbcrsubsampling[1]; + else + rowblock = 1; + rowblockbytes = TIFFVTileSize64(tif, rowblock); /* * Make the rows hold at least one scanline, but fill specified amount * of data if possible. */ - if (rowbytes > STRIP_SIZE_DEFAULT) { - stripbytes = rowbytes; - rowsperstrip = 1; - } else if (rowbytes > 0 ) { - rowsperstrip = STRIP_SIZE_DEFAULT / rowbytes; - stripbytes = rowbytes * rowsperstrip; + if (rowblockbytes > STRIP_SIZE_DEFAULT) { + stripbytes = rowblockbytes; + rowsperstrip = rowblock; + } else if (rowblockbytes > 0 ) { + uint32 rowblocksperstrip; + rowblocksperstrip = (uint32) (STRIP_SIZE_DEFAULT / rowblockbytes); + rowsperstrip = rowblocksperstrip * rowblock; + stripbytes = rowblocksperstrip * rowblockbytes; } - else - return; + else + return; - /* + /* * never increase the number of strips in an image */ if (rowsperstrip >= td->td_rowsperstrip) return; - nstrips = (tstrip_t) TIFFhowmany(bytecount, stripbytes); - if( nstrips == 0 ) /* something is wonky, do nothing. */ - return; + nstrips64 = TIFFhowmany_64(bytecount, stripbytes); + if ((nstrips64==0)||(nstrips64>0xFFFFFFFF)) /* something is wonky, do nothing. */ + return; + nstrips32 = (uint32)nstrips64; - newcounts = (uint32*) _TIFFCheckMalloc(tif, nstrips, sizeof (uint32), + newcounts = (uint64*) _TIFFCheckMalloc(tif, nstrips32, sizeof (uint64), "for chopped \"StripByteCounts\" array"); - newoffsets = (uint32*) _TIFFCheckMalloc(tif, nstrips, sizeof (uint32), + newoffsets = (uint64*) _TIFFCheckMalloc(tif, nstrips32, sizeof (uint64), "for chopped \"StripOffsets\" array"); if (newcounts == NULL || newoffsets == NULL) { - /* + /* * Unable to allocate new strip information, give up and use * the original one strip information. */ @@ -1992,8 +5534,8 @@ ChopUpSingleUncompressedStrip(TIFF* tif) * Fill the strip information arrays with new bytecounts and offsets * that reflect the broken-up format. */ - for (strip = 0; strip < nstrips; strip++) { - if ((uint32)stripbytes > bytecount) + for (strip = 0; strip < nstrips32; strip++) { + if (stripbytes > bytecount) stripbytes = bytecount; newcounts[strip] = stripbytes; newoffsets[strip] = offset; @@ -2003,7 +5545,7 @@ ChopUpSingleUncompressedStrip(TIFF* tif) /* * Replace old single strip info with multi-strip info. */ - td->td_stripsperimage = td->td_nstrips = nstrips; + td->td_stripsperimage = td->td_nstrips = nstrips32; TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, rowsperstrip); _TIFFfree(td->td_stripbytecount); @@ -2013,4 +5555,59 @@ ChopUpSingleUncompressedStrip(TIFF* tif) td->td_stripbytecountsorted = 1; } +int _TIFFFillStriles( TIFF *tif ) +{ +#if defined(DEFER_STRILE_LOAD) + register TIFFDirectory *td = &tif->tif_dir; + int return_value = 1; + + if( td->td_stripoffset != NULL ) + return 1; + + if( td->td_stripoffset_entry.tdir_count == 0 ) + return 0; + + if (!TIFFFetchStripThing(tif,&(td->td_stripoffset_entry), + td->td_nstrips,&td->td_stripoffset)) + { + return_value = 0; + } + + if (!TIFFFetchStripThing(tif,&(td->td_stripbytecount_entry), + td->td_nstrips,&td->td_stripbytecount)) + { + return_value = 0; + } + + _TIFFmemset( &(td->td_stripoffset_entry), 0, sizeof(TIFFDirEntry)); + _TIFFmemset( &(td->td_stripbytecount_entry), 0, sizeof(TIFFDirEntry)); + + if (tif->tif_dir.td_nstrips > 1 && return_value == 1 ) { + uint32 strip; + + tif->tif_dir.td_stripbytecountsorted = 1; + for (strip = 1; strip < tif->tif_dir.td_nstrips; strip++) { + if (tif->tif_dir.td_stripoffset[strip - 1] > + tif->tif_dir.td_stripoffset[strip]) { + tif->tif_dir.td_stripbytecountsorted = 0; + break; + } + } + } + + return return_value; +#else /* !defined(DEFER_STRILE_LOAD) */ + (void) tif; + return 1; +#endif +} + + /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_dirwrite.c b/src/3rdparty/libtiff/libtiff/tif_dirwrite.c index 5148097d..fa20609 100644 --- a/src/3rdparty/libtiff/libtiff/tif_dirwrite.c +++ b/src/3rdparty/libtiff/libtiff/tif_dirwrite.c @@ -1,26 +1,26 @@ -/* $Id: tif_dirwrite.c,v 1.37.2.6 2009-10-31 21:51:08 bfriesen Exp $ */ +/* $Id: tif_dirwrite.c,v 1.77 2012-07-06 19:18:31 bfriesen Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * - * Permission to use, copy, modify, distribute, and sell this software and + * 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. - * + * + * 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 + * 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. */ @@ -32,44 +32,144 @@ #include "tiffiop.h" #ifdef HAVE_IEEEFP -# define TIFFCvtNativeToIEEEFloat(tif, n, fp) -# define TIFFCvtNativeToIEEEDouble(tif, n, dp) +#define TIFFCvtNativeToIEEEFloat(tif, n, fp) +#define TIFFCvtNativeToIEEEDouble(tif, n, dp) #else -extern void TIFFCvtNativeToIEEEFloat(TIFF*, uint32, float*); -extern void TIFFCvtNativeToIEEEDouble(TIFF*, uint32, double*); +extern void TIFFCvtNativeToIEEEFloat(TIFF* tif, uint32 n, float* fp); +extern void TIFFCvtNativeToIEEEDouble(TIFF* tif, uint32 n, double* dp); #endif -static int TIFFWriteNormalTag(TIFF*, TIFFDirEntry*, const TIFFFieldInfo*); -static void TIFFSetupShortLong(TIFF*, ttag_t, TIFFDirEntry*, uint32); -static void TIFFSetupShort(TIFF*, ttag_t, TIFFDirEntry*, uint16); -static int TIFFSetupShortPair(TIFF*, ttag_t, TIFFDirEntry*); -static int TIFFWritePerSampleShorts(TIFF*, ttag_t, TIFFDirEntry*); -static int TIFFWritePerSampleAnys(TIFF*, TIFFDataType, ttag_t, TIFFDirEntry*); -static int TIFFWriteShortTable(TIFF*, ttag_t, TIFFDirEntry*, uint32, uint16**); -static int TIFFWriteShortArray(TIFF*, TIFFDirEntry*, uint16*); -static int TIFFWriteLongArray(TIFF *, TIFFDirEntry*, uint32*); -static int TIFFWriteRationalArray(TIFF *, TIFFDirEntry*, float*); -static int TIFFWriteFloatArray(TIFF *, TIFFDirEntry*, float*); -static int TIFFWriteDoubleArray(TIFF *, TIFFDirEntry*, double*); -static int TIFFWriteByteArray(TIFF*, TIFFDirEntry*, char*); -static int TIFFWriteAnyArray(TIFF*, - TIFFDataType, ttag_t, TIFFDirEntry*, uint32, double*); -static int TIFFWriteTransferFunction(TIFF*, TIFFDirEntry*); -static int TIFFWriteInkNames(TIFF*, TIFFDirEntry*); -static int TIFFWriteData(TIFF*, TIFFDirEntry*, char*); -static int TIFFLinkDirectory(TIFF*); - -#define WriteRationalPair(type, tag1, v1, tag2, v2) { \ - TIFFWriteRational((tif), (type), (tag1), (dir), (v1)) \ - TIFFWriteRational((tif), (type), (tag2), (dir)+1, (v2)) \ - (dir)++; \ -} -#define TIFFWriteRational(tif, type, tag, dir, v) \ - (dir)->tdir_tag = (tag); \ - (dir)->tdir_type = (type); \ - (dir)->tdir_count = 1; \ - if (!TIFFWriteRationalArray((tif), (dir), &(v))) \ - goto bad; +static int TIFFWriteDirectorySec(TIFF* tif, int isimage, int imagedone, uint64* pdiroff); + +static int TIFFWriteDirectoryTagSampleformatArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, double* value); +#if 0 +static int TIFFWriteDirectoryTagSampleformatPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value); +#endif + +static int TIFFWriteDirectoryTagAscii(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, char* value); +static int TIFFWriteDirectoryTagUndefinedArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value); +#ifdef notdef +static int TIFFWriteDirectoryTagByte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint8 value); +#endif +static int TIFFWriteDirectoryTagByteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value); +#if 0 +static int TIFFWriteDirectoryTagBytePerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint8 value); +#endif +#ifdef notdef +static int TIFFWriteDirectoryTagSbyte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int8 value); +#endif +static int TIFFWriteDirectoryTagSbyteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int8* value); +#if 0 +static int TIFFWriteDirectoryTagSbytePerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int8 value); +#endif +static int TIFFWriteDirectoryTagShort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 value); +static int TIFFWriteDirectoryTagShortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint16* value); +static int TIFFWriteDirectoryTagShortPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 value); +#ifdef notdef +static int TIFFWriteDirectoryTagSshort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int16 value); +#endif +static int TIFFWriteDirectoryTagSshortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int16* value); +#if 0 +static int TIFFWriteDirectoryTagSshortPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int16 value); +#endif +static int TIFFWriteDirectoryTagLong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value); +static int TIFFWriteDirectoryTagLongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value); +#if 0 +static int TIFFWriteDirectoryTagLongPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value); +#endif +#ifdef notdef +static int TIFFWriteDirectoryTagSlong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int32 value); +#endif +static int TIFFWriteDirectoryTagSlongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int32* value); +#if 0 +static int TIFFWriteDirectoryTagSlongPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int32 value); +#endif +#ifdef notdef +static int TIFFWriteDirectoryTagLong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint64 value); +#endif +static int TIFFWriteDirectoryTagLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value); +#ifdef notdef +static int TIFFWriteDirectoryTagSlong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int64 value); +#endif +static int TIFFWriteDirectoryTagSlong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int64* value); +static int TIFFWriteDirectoryTagRational(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value); +static int TIFFWriteDirectoryTagRationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value); +static int TIFFWriteDirectoryTagSrationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value); +#ifdef notdef +static int TIFFWriteDirectoryTagFloat(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, float value); +#endif +static int TIFFWriteDirectoryTagFloatArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value); +#if 0 +static int TIFFWriteDirectoryTagFloatPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, float value); +#endif +#ifdef notdef +static int TIFFWriteDirectoryTagDouble(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value); +#endif +static int TIFFWriteDirectoryTagDoubleArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, double* value); +#if 0 +static int TIFFWriteDirectoryTagDoublePerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value); +#endif +static int TIFFWriteDirectoryTagIfdArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value); +#ifdef notdef +static int TIFFWriteDirectoryTagIfd8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value); +#endif +static int TIFFWriteDirectoryTagShortLong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value); +static int TIFFWriteDirectoryTagLongLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value); +static int TIFFWriteDirectoryTagIfdIfd8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value); +#ifdef notdef +static int TIFFWriteDirectoryTagShortLongLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value); +#endif +static int TIFFWriteDirectoryTagColormap(TIFF* tif, uint32* ndir, TIFFDirEntry* dir); +static int TIFFWriteDirectoryTagTransferfunction(TIFF* tif, uint32* ndir, TIFFDirEntry* dir); +static int TIFFWriteDirectoryTagSubifd(TIFF* tif, uint32* ndir, TIFFDirEntry* dir); + +static int TIFFWriteDirectoryTagCheckedAscii(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, char* value); +static int TIFFWriteDirectoryTagCheckedUndefinedArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value); +#ifdef notdef +static int TIFFWriteDirectoryTagCheckedByte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint8 value); +#endif +static int TIFFWriteDirectoryTagCheckedByteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value); +#ifdef notdef +static int TIFFWriteDirectoryTagCheckedSbyte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int8 value); +#endif +static int TIFFWriteDirectoryTagCheckedSbyteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int8* value); +static int TIFFWriteDirectoryTagCheckedShort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 value); +static int TIFFWriteDirectoryTagCheckedShortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint16* value); +#ifdef notdef +static int TIFFWriteDirectoryTagCheckedSshort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int16 value); +#endif +static int TIFFWriteDirectoryTagCheckedSshortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int16* value); +static int TIFFWriteDirectoryTagCheckedLong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value); +static int TIFFWriteDirectoryTagCheckedLongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value); +#ifdef notdef +static int TIFFWriteDirectoryTagCheckedSlong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int32 value); +#endif +static int TIFFWriteDirectoryTagCheckedSlongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int32* value); +#ifdef notdef +static int TIFFWriteDirectoryTagCheckedLong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint64 value); +#endif +static int TIFFWriteDirectoryTagCheckedLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value); +#ifdef notdef +static int TIFFWriteDirectoryTagCheckedSlong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int64 value); +#endif +static int TIFFWriteDirectoryTagCheckedSlong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int64* value); +static int TIFFWriteDirectoryTagCheckedRational(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value); +static int TIFFWriteDirectoryTagCheckedRationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value); +static int TIFFWriteDirectoryTagCheckedSrationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value); +#ifdef notdef +static int TIFFWriteDirectoryTagCheckedFloat(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, float value); +#endif +static int TIFFWriteDirectoryTagCheckedFloatArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value); +#ifdef notdef +static int TIFFWriteDirectoryTagCheckedDouble(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value); +#endif +static int TIFFWriteDirectoryTagCheckedDoubleArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, double* value); +static int TIFFWriteDirectoryTagCheckedIfdArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value); +static int TIFFWriteDirectoryTagCheckedIfd8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value); + +static int TIFFWriteDirectoryTagData(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 datatype, uint32 count, uint32 datalength, void* data); + +static int TIFFLinkDirectory(TIFF*); /* * Write the contents of the current directory @@ -77,1244 +177,2188 @@ static int TIFFLinkDirectory(TIFF*); * handle overwriting a directory with auxiliary * storage that's been changed. */ +int +TIFFWriteDirectory(TIFF* tif) +{ + return TIFFWriteDirectorySec(tif,TRUE,TRUE,NULL); +} + +/* + * Similar to TIFFWriteDirectory(), writes the directory out + * but leaves all data structures in memory so that it can be + * written again. This will make a partially written TIFF file + * readable before it is successfully completed/closed. + */ +int +TIFFCheckpointDirectory(TIFF* tif) +{ + int rc; + /* Setup the strips arrays, if they haven't already been. */ + if (tif->tif_dir.td_stripoffset == NULL) + (void) TIFFSetupStrips(tif); + rc = TIFFWriteDirectorySec(tif,TRUE,FALSE,NULL); + (void) TIFFSetWriteOffset(tif, TIFFSeekFile(tif, 0, SEEK_END)); + return rc; +} + +int +TIFFWriteCustomDirectory(TIFF* tif, uint64* pdiroff) +{ + return TIFFWriteDirectorySec(tif,FALSE,FALSE,pdiroff); +} + +/* + * Similar to TIFFWriteDirectory(), but if the directory has already + * been written once, it is relocated to the end of the file, in case it + * has changed in size. Note that this will result in the loss of the + * previously used directory space. + */ +int +TIFFRewriteDirectory( TIFF *tif ) +{ + static const char module[] = "TIFFRewriteDirectory"; + + /* We don't need to do anything special if it hasn't been written. */ + if( tif->tif_diroff == 0 ) + return TIFFWriteDirectory( tif ); + + /* + * Find and zero the pointer to this directory, so that TIFFLinkDirectory + * will cause it to be added after this directories current pre-link. + */ + + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + if (tif->tif_header.classic.tiff_diroff == tif->tif_diroff) + { + tif->tif_header.classic.tiff_diroff = 0; + tif->tif_diroff = 0; + + TIFFSeekFile(tif,4,SEEK_SET); + if (!WriteOK(tif, &(tif->tif_header.classic.tiff_diroff),4)) + { + TIFFErrorExt(tif->tif_clientdata, tif->tif_name, + "Error updating TIFF header"); + return (0); + } + } + else + { + uint32 nextdir; + nextdir = tif->tif_header.classic.tiff_diroff; + while(1) { + uint16 dircount; + uint32 nextnextdir; + + if (!SeekOK(tif, nextdir) || + !ReadOK(tif, &dircount, 2)) { + TIFFErrorExt(tif->tif_clientdata, module, + "Error fetching directory count"); + return (0); + } + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabShort(&dircount); + (void) TIFFSeekFile(tif, + nextdir+2+dircount*12, SEEK_SET); + if (!ReadOK(tif, &nextnextdir, 4)) { + TIFFErrorExt(tif->tif_clientdata, module, + "Error fetching directory link"); + return (0); + } + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabLong(&nextnextdir); + if (nextnextdir==tif->tif_diroff) + { + uint32 m; + m=0; + (void) TIFFSeekFile(tif, + nextdir+2+dircount*12, SEEK_SET); + if (!WriteOK(tif, &m, 4)) { + TIFFErrorExt(tif->tif_clientdata, module, + "Error writing directory link"); + return (0); + } + tif->tif_diroff=0; + break; + } + nextdir=nextnextdir; + } + } + } + else + { + if (tif->tif_header.big.tiff_diroff == tif->tif_diroff) + { + tif->tif_header.big.tiff_diroff = 0; + tif->tif_diroff = 0; + + TIFFSeekFile(tif,8,SEEK_SET); + if (!WriteOK(tif, &(tif->tif_header.big.tiff_diroff),8)) + { + TIFFErrorExt(tif->tif_clientdata, tif->tif_name, + "Error updating TIFF header"); + return (0); + } + } + else + { + uint64 nextdir; + nextdir = tif->tif_header.big.tiff_diroff; + while(1) { + uint64 dircount64; + uint16 dircount; + uint64 nextnextdir; + + if (!SeekOK(tif, nextdir) || + !ReadOK(tif, &dircount64, 8)) { + TIFFErrorExt(tif->tif_clientdata, module, + "Error fetching directory count"); + return (0); + } + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabLong8(&dircount64); + if (dircount64>0xFFFF) + { + TIFFErrorExt(tif->tif_clientdata, module, + "Sanity check on tag count failed, likely corrupt TIFF"); + return (0); + } + dircount=(uint16)dircount64; + (void) TIFFSeekFile(tif, + nextdir+8+dircount*20, SEEK_SET); + if (!ReadOK(tif, &nextnextdir, 8)) { + TIFFErrorExt(tif->tif_clientdata, module, + "Error fetching directory link"); + return (0); + } + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabLong8(&nextnextdir); + if (nextnextdir==tif->tif_diroff) + { + uint64 m; + m=0; + (void) TIFFSeekFile(tif, + nextdir+8+dircount*20, SEEK_SET); + if (!WriteOK(tif, &m, 8)) { + TIFFErrorExt(tif->tif_clientdata, module, + "Error writing directory link"); + return (0); + } + tif->tif_diroff=0; + break; + } + nextdir=nextnextdir; + } + } + } + + /* + * Now use TIFFWriteDirectory() normally. + */ + + return TIFFWriteDirectory( tif ); +} + static int -_TIFFWriteDirectory(TIFF* tif, int done) +TIFFWriteDirectorySec(TIFF* tif, int isimage, int imagedone, uint64* pdiroff) { - uint16 dircount; - toff_t diroff; - ttag_t tag; - uint32 nfields; - tsize_t dirsize; - char* data; + static const char module[] = "TIFFWriteDirectorySec"; + uint32 ndir; TIFFDirEntry* dir; - TIFFDirectory* td; - unsigned long b, fields[FIELD_SETLONGS]; - int fi, nfi; - + uint32 dirsize; + void* dirmem; + uint32 m; if (tif->tif_mode == O_RDONLY) return (1); + + _TIFFFillStriles( tif ); + /* * Clear write state so that subsequent images with * different characteristics get the right buffers * setup for them. */ - if (done) + if (imagedone) { - if (tif->tif_flags & TIFF_POSTENCODE) { + if (tif->tif_flags & TIFF_POSTENCODE) + { tif->tif_flags &= ~TIFF_POSTENCODE; - if (!(*tif->tif_postencode)(tif)) { - TIFFErrorExt(tif->tif_clientdata, - tif->tif_name, - "Error post-encoding before directory write"); + if (!(*tif->tif_postencode)(tif)) + { + TIFFErrorExt(tif->tif_clientdata,module, + "Error post-encoding before directory write"); return (0); } } - (*tif->tif_close)(tif); /* shutdown encoder */ + (*tif->tif_close)(tif); /* shutdown encoder */ /* * Flush any data that might have been written - * by the compression close+cleanup routines. + * by the compression close+cleanup routines. But + * be careful not to write stuff if we didn't add data + * in the previous steps as the "rawcc" data may well be + * a previously read tile/strip in mixed read/write mode. */ - if (tif->tif_rawcc > 0 - && (tif->tif_flags & TIFF_BEENWRITING) != 0 - && !TIFFFlushData1(tif)) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, + if (tif->tif_rawcc > 0 + && (tif->tif_flags & TIFF_BEENWRITING) != 0 ) + { + if( !TIFFFlushData1(tif) ) + { + TIFFErrorExt(tif->tif_clientdata, module, "Error flushing data before directory write"); return (0); + } } - if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) { + if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) + { _TIFFfree(tif->tif_rawdata); tif->tif_rawdata = NULL; tif->tif_rawcc = 0; tif->tif_rawdatasize = 0; + tif->tif_rawdataoff = 0; + tif->tif_rawdataloaded = 0; } tif->tif_flags &= ~(TIFF_BEENWRITING|TIFF_BUFFERSETUP); } - - td = &tif->tif_dir; - /* - * Size the directory so that we can calculate - * offsets for the data items that aren't kept - * in-place in each field. - */ - nfields = 0; - for (b = 0; b <= FIELD_LAST; b++) - if (TIFFFieldSet(tif, b) && b != FIELD_CUSTOM) - nfields += (b < FIELD_SUBFILETYPE ? 2 : 1); - nfields += td->td_customValueCount; - dirsize = nfields * sizeof (TIFFDirEntry); - data = (char*) _TIFFmalloc(dirsize); - if (data == NULL) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Cannot write directory, out of space"); - return (0); - } - /* - * Directory hasn't been placed yet, put - * it at the end of the file and link it - * into the existing directory structure. - */ - if (tif->tif_diroff == 0 && !TIFFLinkDirectory(tif)) - goto bad; - tif->tif_dataoff = (toff_t)( - tif->tif_diroff + sizeof (uint16) + dirsize + sizeof (toff_t)); - if (tif->tif_dataoff & 1) - tif->tif_dataoff++; - (void) TIFFSeekFile(tif, tif->tif_dataoff, SEEK_SET); - tif->tif_curdir++; - dir = (TIFFDirEntry*) data; - /* - * Setup external form of directory - * entries and write data items. - */ - _TIFFmemcpy(fields, td->td_fieldsset, sizeof (fields)); - /* - * Write out ExtraSamples tag only if - * extra samples are present in the data. - */ - if (FieldSet(fields, FIELD_EXTRASAMPLES) && !td->td_extrasamples) { - ResetFieldBit(fields, FIELD_EXTRASAMPLES); - nfields--; - dirsize -= sizeof (TIFFDirEntry); - } /*XXX*/ - for (fi = 0, nfi = tif->tif_nfields; nfi > 0; nfi--, fi++) { - const TIFFFieldInfo* fip = tif->tif_fieldinfo[fi]; - - /* - * For custom fields, we test to see if the custom field - * is set or not. For normal fields, we just use the - * FieldSet test. - */ - if( fip->field_bit == FIELD_CUSTOM ) - { - int ci, is_set = FALSE; - - for( ci = 0; ci < td->td_customValueCount; ci++ ) - is_set |= (td->td_customValues[ci].info == fip); - - if( !is_set ) - continue; - } - else if (!FieldSet(fields, fip->field_bit)) - continue; - - /* - * Handle other fields. - */ - switch (fip->field_bit) + dir=NULL; + dirmem=NULL; + dirsize=0; + while (1) + { + ndir=0; + if (isimage) { - case FIELD_STRIPOFFSETS: - /* - * We use one field bit for both strip and tile - - * offsets, and so must be careful in selecting - * the appropriate field descriptor (so that tags - * are written in sorted order). - */ - tag = isTiled(tif) ? - TIFFTAG_TILEOFFSETS : TIFFTAG_STRIPOFFSETS; - if (tag != fip->field_tag) - continue; - - dir->tdir_tag = (uint16) tag; - dir->tdir_type = (uint16) TIFF_LONG; - dir->tdir_count = (uint32) td->td_nstrips; - if (!TIFFWriteLongArray(tif, dir, td->td_stripoffset)) - goto bad; - break; - case FIELD_STRIPBYTECOUNTS: - /* - * We use one field bit for both strip and tile - * byte counts, and so must be careful in selecting - * the appropriate field descriptor (so that tags - * are written in sorted order). - */ - tag = isTiled(tif) ? - TIFFTAG_TILEBYTECOUNTS : TIFFTAG_STRIPBYTECOUNTS; - if (tag != fip->field_tag) - continue; - - dir->tdir_tag = (uint16) tag; - dir->tdir_type = (uint16) TIFF_LONG; - dir->tdir_count = (uint32) td->td_nstrips; - if (!TIFFWriteLongArray(tif, dir, td->td_stripbytecount)) - goto bad; - break; - case FIELD_ROWSPERSTRIP: - TIFFSetupShortLong(tif, TIFFTAG_ROWSPERSTRIP, - dir, td->td_rowsperstrip); - break; - case FIELD_COLORMAP: - if (!TIFFWriteShortTable(tif, TIFFTAG_COLORMAP, dir, - 3, td->td_colormap)) - goto bad; - break; - case FIELD_IMAGEDIMENSIONS: - TIFFSetupShortLong(tif, TIFFTAG_IMAGEWIDTH, - dir++, td->td_imagewidth); - TIFFSetupShortLong(tif, TIFFTAG_IMAGELENGTH, - dir, td->td_imagelength); - break; - case FIELD_TILEDIMENSIONS: - TIFFSetupShortLong(tif, TIFFTAG_TILEWIDTH, - dir++, td->td_tilewidth); - TIFFSetupShortLong(tif, TIFFTAG_TILELENGTH, - dir, td->td_tilelength); - break; - case FIELD_COMPRESSION: - TIFFSetupShort(tif, TIFFTAG_COMPRESSION, - dir, td->td_compression); - break; - case FIELD_PHOTOMETRIC: - TIFFSetupShort(tif, TIFFTAG_PHOTOMETRIC, - dir, td->td_photometric); - break; - case FIELD_POSITION: - WriteRationalPair(TIFF_RATIONAL, - TIFFTAG_XPOSITION, td->td_xposition, - TIFFTAG_YPOSITION, td->td_yposition); - break; - case FIELD_RESOLUTION: - WriteRationalPair(TIFF_RATIONAL, - TIFFTAG_XRESOLUTION, td->td_xresolution, - TIFFTAG_YRESOLUTION, td->td_yresolution); - break; - case FIELD_BITSPERSAMPLE: - case FIELD_MINSAMPLEVALUE: - case FIELD_MAXSAMPLEVALUE: - case FIELD_SAMPLEFORMAT: - if (!TIFFWritePerSampleShorts(tif, fip->field_tag, dir)) - goto bad; - break; - case FIELD_SMINSAMPLEVALUE: - case FIELD_SMAXSAMPLEVALUE: - if (!TIFFWritePerSampleAnys(tif, - _TIFFSampleToTagType(tif), fip->field_tag, dir)) - goto bad; - break; - case FIELD_PAGENUMBER: - case FIELD_HALFTONEHINTS: - case FIELD_YCBCRSUBSAMPLING: - if (!TIFFSetupShortPair(tif, fip->field_tag, dir)) - goto bad; - break; - case FIELD_INKNAMES: - if (!TIFFWriteInkNames(tif, dir)) - goto bad; - break; - case FIELD_TRANSFERFUNCTION: - if (!TIFFWriteTransferFunction(tif, dir)) - goto bad; - break; - case FIELD_SUBIFD: - /* - * XXX: Always write this field using LONG type - * for backward compatibility. - */ - dir->tdir_tag = (uint16) fip->field_tag; - dir->tdir_type = (uint16) TIFF_LONG; - dir->tdir_count = (uint32) td->td_nsubifd; - if (!TIFFWriteLongArray(tif, dir, td->td_subifd)) - goto bad; - /* - * Total hack: if this directory includes a SubIFD - * tag then force the next <n> directories to be - * written as ``sub directories'' of this one. This - * is used to write things like thumbnails and - * image masks that one wants to keep out of the - * normal directory linkage access mechanism. - */ - if (dir->tdir_count > 0) { - tif->tif_flags |= TIFF_INSUBIFD; - tif->tif_nsubifd = (uint16) dir->tdir_count; - if (dir->tdir_count > 1) - tif->tif_subifdoff = dir->tdir_offset; + if (TIFFFieldSet(tif,FIELD_IMAGEDIMENSIONS)) + { + if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_IMAGEWIDTH,tif->tif_dir.td_imagewidth)) + goto bad; + if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_IMAGELENGTH,tif->tif_dir.td_imagelength)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_TILEDIMENSIONS)) + { + if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_TILEWIDTH,tif->tif_dir.td_tilewidth)) + goto bad; + if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_TILELENGTH,tif->tif_dir.td_tilelength)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_RESOLUTION)) + { + if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_XRESOLUTION,tif->tif_dir.td_xresolution)) + goto bad; + if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_YRESOLUTION,tif->tif_dir.td_yresolution)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_POSITION)) + { + if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_XPOSITION,tif->tif_dir.td_xposition)) + goto bad; + if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_YPOSITION,tif->tif_dir.td_yposition)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_SUBFILETYPE)) + { + if (!TIFFWriteDirectoryTagLong(tif,&ndir,dir,TIFFTAG_SUBFILETYPE,tif->tif_dir.td_subfiletype)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_BITSPERSAMPLE)) + { + if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_BITSPERSAMPLE,tif->tif_dir.td_bitspersample)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_COMPRESSION)) + { + if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_COMPRESSION,tif->tif_dir.td_compression)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_PHOTOMETRIC)) + { + if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_PHOTOMETRIC,tif->tif_dir.td_photometric)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_THRESHHOLDING)) + { + if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_THRESHHOLDING,tif->tif_dir.td_threshholding)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_FILLORDER)) + { + if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_FILLORDER,tif->tif_dir.td_fillorder)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_ORIENTATION)) + { + if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_ORIENTATION,tif->tif_dir.td_orientation)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_SAMPLESPERPIXEL)) + { + if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_SAMPLESPERPIXEL,tif->tif_dir.td_samplesperpixel)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_ROWSPERSTRIP)) + { + if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_ROWSPERSTRIP,tif->tif_dir.td_rowsperstrip)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_MINSAMPLEVALUE)) + { + if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_MINSAMPLEVALUE,tif->tif_dir.td_minsamplevalue)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_MAXSAMPLEVALUE)) + { + if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_MAXSAMPLEVALUE,tif->tif_dir.td_maxsamplevalue)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_PLANARCONFIG)) + { + if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_PLANARCONFIG,tif->tif_dir.td_planarconfig)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_RESOLUTIONUNIT)) + { + if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_RESOLUTIONUNIT,tif->tif_dir.td_resolutionunit)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_PAGENUMBER)) + { + if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_PAGENUMBER,2,&tif->tif_dir.td_pagenumber[0])) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_STRIPBYTECOUNTS)) + { + if (!isTiled(tif)) + { + if (!TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_STRIPBYTECOUNTS,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripbytecount)) + goto bad; + } else - tif->tif_subifdoff = (uint32)( - tif->tif_diroff - + sizeof (uint16) - + ((char*)&dir->tdir_offset-data)); + { + if (!TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_TILEBYTECOUNTS,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripbytecount)) + goto bad; + } } - break; - default: - /* XXX: Should be fixed and removed. */ - if (fip->field_tag == TIFFTAG_DOTRANGE) { - if (!TIFFSetupShortPair(tif, fip->field_tag, dir)) + if (TIFFFieldSet(tif,FIELD_STRIPOFFSETS)) + { + if (!isTiled(tif)) + { + if (!TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_STRIPOFFSETS,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripoffset)) + goto bad; + } + else + { + if (!TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_TILEOFFSETS,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripoffset)) + goto bad; + } + } + if (TIFFFieldSet(tif,FIELD_COLORMAP)) + { + if (!TIFFWriteDirectoryTagColormap(tif,&ndir,dir)) goto bad; } - else if (!TIFFWriteNormalTag(tif, dir, fip)) - goto bad; + if (TIFFFieldSet(tif,FIELD_EXTRASAMPLES)) + { + if (tif->tif_dir.td_extrasamples) + { + uint16 na; + uint16* nb; + TIFFGetFieldDefaulted(tif,TIFFTAG_EXTRASAMPLES,&na,&nb); + if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_EXTRASAMPLES,na,nb)) + goto bad; + } + } + if (TIFFFieldSet(tif,FIELD_SAMPLEFORMAT)) + { + if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_SAMPLEFORMAT,tif->tif_dir.td_sampleformat)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_SMINSAMPLEVALUE)) + { + if (!TIFFWriteDirectoryTagSampleformatArray(tif,&ndir,dir,TIFFTAG_SMINSAMPLEVALUE,tif->tif_dir.td_samplesperpixel,tif->tif_dir.td_sminsamplevalue)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_SMAXSAMPLEVALUE)) + { + if (!TIFFWriteDirectoryTagSampleformatArray(tif,&ndir,dir,TIFFTAG_SMAXSAMPLEVALUE,tif->tif_dir.td_samplesperpixel,tif->tif_dir.td_smaxsamplevalue)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_IMAGEDEPTH)) + { + if (!TIFFWriteDirectoryTagLong(tif,&ndir,dir,TIFFTAG_IMAGEDEPTH,tif->tif_dir.td_imagedepth)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_TILEDEPTH)) + { + if (!TIFFWriteDirectoryTagLong(tif,&ndir,dir,TIFFTAG_TILEDEPTH,tif->tif_dir.td_tiledepth)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_HALFTONEHINTS)) + { + if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_HALFTONEHINTS,2,&tif->tif_dir.td_halftonehints[0])) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_YCBCRSUBSAMPLING)) + { + if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_YCBCRSUBSAMPLING,2,&tif->tif_dir.td_ycbcrsubsampling[0])) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_YCBCRPOSITIONING)) + { + if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_YCBCRPOSITIONING,tif->tif_dir.td_ycbcrpositioning)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_REFBLACKWHITE)) + { + if (!TIFFWriteDirectoryTagRationalArray(tif,&ndir,dir,TIFFTAG_REFERENCEBLACKWHITE,6,tif->tif_dir.td_refblackwhite)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_TRANSFERFUNCTION)) + { + if (!TIFFWriteDirectoryTagTransferfunction(tif,&ndir,dir)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_INKNAMES)) + { + if (!TIFFWriteDirectoryTagAscii(tif,&ndir,dir,TIFFTAG_INKNAMES,tif->tif_dir.td_inknameslen,tif->tif_dir.td_inknames)) + goto bad; + } + if (TIFFFieldSet(tif,FIELD_SUBIFD)) + { + if (!TIFFWriteDirectoryTagSubifd(tif,&ndir,dir)) + goto bad; + } + { + uint32 n; + for (n=0; n<tif->tif_nfields; n++) { + const TIFFField* o; + o = tif->tif_fields[n]; + if ((o->field_bit>=FIELD_CODEC)&&(TIFFFieldSet(tif,o->field_bit))) + { + switch (o->get_field_type) + { + case TIFF_SETGET_ASCII: + { + uint32 pa; + char* pb; + assert(o->field_type==TIFF_ASCII); + assert(o->field_readcount==TIFF_VARIABLE); + assert(o->field_passcount==0); + TIFFGetField(tif,o->field_tag,&pb); + pa=(uint32)(strlen(pb)); + if (!TIFFWriteDirectoryTagAscii(tif,&ndir,dir,o->field_tag,pa,pb)) + goto bad; + } + break; + case TIFF_SETGET_UINT16: + { + uint16 p; + assert(o->field_type==TIFF_SHORT); + assert(o->field_readcount==1); + assert(o->field_passcount==0); + TIFFGetField(tif,o->field_tag,&p); + if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,o->field_tag,p)) + goto bad; + } + break; + case TIFF_SETGET_UINT32: + { + uint32 p; + assert(o->field_type==TIFF_LONG); + assert(o->field_readcount==1); + assert(o->field_passcount==0); + TIFFGetField(tif,o->field_tag,&p); + if (!TIFFWriteDirectoryTagLong(tif,&ndir,dir,o->field_tag,p)) + goto bad; + } + break; + case TIFF_SETGET_C32_UINT8: + { + uint32 pa; + void* pb; + assert(o->field_type==TIFF_UNDEFINED); + assert(o->field_readcount==TIFF_VARIABLE2); + assert(o->field_passcount==1); + TIFFGetField(tif,o->field_tag,&pa,&pb); + if (!TIFFWriteDirectoryTagUndefinedArray(tif,&ndir,dir,o->field_tag,pa,pb)) + goto bad; + } + break; + default: + assert(0); /* we should never get here */ + break; + } + } + } + } + } + for (m=0; m<(uint32)(tif->tif_dir.td_customValueCount); m++) + { + switch (tif->tif_dir.td_customValues[m].info->field_type) + { + case TIFF_ASCII: + if (!TIFFWriteDirectoryTagAscii(tif,&ndir,dir,tif->tif_dir.td_customValues[m].info->field_tag,tif->tif_dir.td_customValues[m].count,tif->tif_dir.td_customValues[m].value)) + goto bad; + break; + case TIFF_UNDEFINED: + if (!TIFFWriteDirectoryTagUndefinedArray(tif,&ndir,dir,tif->tif_dir.td_customValues[m].info->field_tag,tif->tif_dir.td_customValues[m].count,tif->tif_dir.td_customValues[m].value)) + goto bad; + break; + case TIFF_BYTE: + if (!TIFFWriteDirectoryTagByteArray(tif,&ndir,dir,tif->tif_dir.td_customValues[m].info->field_tag,tif->tif_dir.td_customValues[m].count,tif->tif_dir.td_customValues[m].value)) + goto bad; + break; + case TIFF_SBYTE: + if (!TIFFWriteDirectoryTagSbyteArray(tif,&ndir,dir,tif->tif_dir.td_customValues[m].info->field_tag,tif->tif_dir.td_customValues[m].count,tif->tif_dir.td_customValues[m].value)) + goto bad; + break; + case TIFF_SHORT: + if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,tif->tif_dir.td_customValues[m].info->field_tag,tif->tif_dir.td_customValues[m].count,tif->tif_dir.td_customValues[m].value)) + goto bad; + break; + case TIFF_SSHORT: + if (!TIFFWriteDirectoryTagSshortArray(tif,&ndir,dir,tif->tif_dir.td_customValues[m].info->field_tag,tif->tif_dir.td_customValues[m].count,tif->tif_dir.td_customValues[m].value)) + goto bad; + break; + case TIFF_LONG: + if (!TIFFWriteDirectoryTagLongArray(tif,&ndir,dir,tif->tif_dir.td_customValues[m].info->field_tag,tif->tif_dir.td_customValues[m].count,tif->tif_dir.td_customValues[m].value)) + goto bad; + break; + case TIFF_SLONG: + if (!TIFFWriteDirectoryTagSlongArray(tif,&ndir,dir,tif->tif_dir.td_customValues[m].info->field_tag,tif->tif_dir.td_customValues[m].count,tif->tif_dir.td_customValues[m].value)) + goto bad; + break; + case TIFF_LONG8: + if (!TIFFWriteDirectoryTagLong8Array(tif,&ndir,dir,tif->tif_dir.td_customValues[m].info->field_tag,tif->tif_dir.td_customValues[m].count,tif->tif_dir.td_customValues[m].value)) + goto bad; + break; + case TIFF_SLONG8: + if (!TIFFWriteDirectoryTagSlong8Array(tif,&ndir,dir,tif->tif_dir.td_customValues[m].info->field_tag,tif->tif_dir.td_customValues[m].count,tif->tif_dir.td_customValues[m].value)) + goto bad; + break; + case TIFF_RATIONAL: + if (!TIFFWriteDirectoryTagRationalArray(tif,&ndir,dir,tif->tif_dir.td_customValues[m].info->field_tag,tif->tif_dir.td_customValues[m].count,tif->tif_dir.td_customValues[m].value)) + goto bad; + break; + case TIFF_SRATIONAL: + if (!TIFFWriteDirectoryTagSrationalArray(tif,&ndir,dir,tif->tif_dir.td_customValues[m].info->field_tag,tif->tif_dir.td_customValues[m].count,tif->tif_dir.td_customValues[m].value)) + goto bad; + break; + case TIFF_FLOAT: + if (!TIFFWriteDirectoryTagFloatArray(tif,&ndir,dir,tif->tif_dir.td_customValues[m].info->field_tag,tif->tif_dir.td_customValues[m].count,tif->tif_dir.td_customValues[m].value)) + goto bad; + break; + case TIFF_DOUBLE: + if (!TIFFWriteDirectoryTagDoubleArray(tif,&ndir,dir,tif->tif_dir.td_customValues[m].info->field_tag,tif->tif_dir.td_customValues[m].count,tif->tif_dir.td_customValues[m].value)) + goto bad; + break; + case TIFF_IFD: + if (!TIFFWriteDirectoryTagIfdArray(tif,&ndir,dir,tif->tif_dir.td_customValues[m].info->field_tag,tif->tif_dir.td_customValues[m].count,tif->tif_dir.td_customValues[m].value)) + goto bad; + break; + case TIFF_IFD8: + if (!TIFFWriteDirectoryTagIfdIfd8Array(tif,&ndir,dir,tif->tif_dir.td_customValues[m].info->field_tag,tif->tif_dir.td_customValues[m].count,tif->tif_dir.td_customValues[m].value)) + goto bad; + break; + default: + assert(0); /* we should never get here */ + break; + } + } + if (dir!=NULL) break; + dir=_TIFFmalloc(ndir*sizeof(TIFFDirEntry)); + if (dir==NULL) + { + TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); + goto bad; } - dir++; - - if( fip->field_bit != FIELD_CUSTOM ) - ResetFieldBit(fields, fip->field_bit); + if (isimage) + { + if ((tif->tif_diroff==0)&&(!TIFFLinkDirectory(tif))) + goto bad; + } + else + tif->tif_diroff=(TIFFSeekFile(tif,0,SEEK_END)+1)&(~1); + if (pdiroff!=NULL) + *pdiroff=tif->tif_diroff; + if (!(tif->tif_flags&TIFF_BIGTIFF)) + dirsize=2+ndir*12+4; + else + dirsize=8+ndir*20+8; + tif->tif_dataoff=tif->tif_diroff+dirsize; + if (!(tif->tif_flags&TIFF_BIGTIFF)) + tif->tif_dataoff=(uint32)tif->tif_dataoff; + if ((tif->tif_dataoff<tif->tif_diroff)||(tif->tif_dataoff<(uint64)dirsize)) + { + TIFFErrorExt(tif->tif_clientdata,module,"Maximum TIFF file size exceeded"); + goto bad; + } + if (tif->tif_dataoff&1) + tif->tif_dataoff++; + if (isimage) + tif->tif_curdir++; } - - /* - * Write directory. - */ - dircount = (uint16) nfields; - diroff = (uint32) tif->tif_nextdiroff; - if (tif->tif_flags & TIFF_SWAB) { - /* - * The file's byte order is opposite to the - * native machine architecture. We overwrite - * the directory information with impunity - * because it'll be released below after we - * write it to the file. Note that all the - * other tag construction routines assume that - * we do this byte-swapping; i.e. they only - * byte-swap indirect data. - */ - for (dir = (TIFFDirEntry*) data; dircount; dir++, dircount--) { - TIFFSwabArrayOfShort(&dir->tdir_tag, 2); - TIFFSwabArrayOfLong(&dir->tdir_count, 2); + if (isimage) + { + if (TIFFFieldSet(tif,FIELD_SUBIFD)&&(tif->tif_subifdoff==0)) + { + uint32 na; + TIFFDirEntry* nb; + for (na=0, nb=dir; ; na++, nb++) + { + assert(na<ndir); + if (nb->tdir_tag==TIFFTAG_SUBIFD) + break; + } + if (!(tif->tif_flags&TIFF_BIGTIFF)) + tif->tif_subifdoff=tif->tif_diroff+2+na*12+8; + else + tif->tif_subifdoff=tif->tif_diroff+8+na*20+12; } - dircount = (uint16) nfields; - TIFFSwabShort(&dircount); - TIFFSwabLong(&diroff); - } - (void) TIFFSeekFile(tif, tif->tif_diroff, SEEK_SET); - if (!WriteOK(tif, &dircount, sizeof (dircount))) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Error writing directory count"); + } + dirmem=_TIFFmalloc(dirsize); + if (dirmem==NULL) + { + TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); goto bad; } - if (!WriteOK(tif, data, dirsize)) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Error writing directory contents"); + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + uint8* n; + uint32 nTmp; + TIFFDirEntry* o; + n=dirmem; + *(uint16*)n=ndir; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort((uint16*)n); + n+=2; + o=dir; + for (m=0; m<ndir; m++) + { + *(uint16*)n=o->tdir_tag; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort((uint16*)n); + n+=2; + *(uint16*)n=o->tdir_type; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort((uint16*)n); + n+=2; + nTmp = (uint32)o->tdir_count; + _TIFFmemcpy(n,&nTmp,4); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong((uint32*)n); + n+=4; + /* This is correct. The data has been */ + /* swabbed previously in TIFFWriteDirectoryTagData */ + _TIFFmemcpy(n,&o->tdir_offset,4); + n+=4; + o++; + } + nTmp = (uint32)tif->tif_nextdiroff; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(&nTmp); + _TIFFmemcpy(n,&nTmp,4); + } + else + { + uint8* n; + TIFFDirEntry* o; + n=dirmem; + *(uint64*)n=ndir; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8((uint64*)n); + n+=8; + o=dir; + for (m=0; m<ndir; m++) + { + *(uint16*)n=o->tdir_tag; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort((uint16*)n); + n+=2; + *(uint16*)n=o->tdir_type; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort((uint16*)n); + n+=2; + _TIFFmemcpy(n,&o->tdir_count,8); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8((uint64*)n); + n+=8; + _TIFFmemcpy(n,&o->tdir_offset,8); + n+=8; + o++; + } + _TIFFmemcpy(n,&tif->tif_nextdiroff,8); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8((uint64*)n); + } + _TIFFfree(dir); + dir=NULL; + if (!SeekOK(tif,tif->tif_diroff)) + { + TIFFErrorExt(tif->tif_clientdata,module,"IO error writing directory"); goto bad; } - if (!WriteOK(tif, &diroff, sizeof (uint32))) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Error writing directory link"); + if (!WriteOK(tif,dirmem,(tmsize_t)dirsize)) + { + TIFFErrorExt(tif->tif_clientdata,module,"IO error writing directory"); goto bad; } - if (done) { + _TIFFfree(dirmem); + if (imagedone) + { TIFFFreeDirectory(tif); tif->tif_flags &= ~TIFF_DIRTYDIRECT; + tif->tif_flags &= ~TIFF_DIRTYSTRIP; (*tif->tif_cleanup)(tif); - /* * Reset directory-related state for subsequent * directories. */ TIFFCreateDirectory(tif); } - _TIFFfree(data); - return (1); + return(1); bad: - _TIFFfree(data); - return (0); + if (dir!=NULL) + _TIFFfree(dir); + if (dirmem!=NULL) + _TIFFfree(dirmem); + return(0); } -#undef WriteRationalPair -int -TIFFWriteDirectory(TIFF* tif) +static int +TIFFWriteDirectoryTagSampleformatArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, double* value) { - return _TIFFWriteDirectory(tif, TRUE); + static const char module[] = "TIFFWriteDirectoryTagSampleformatArray"; + void* conv; + uint32 i; + int ok; + conv = _TIFFmalloc(count*sizeof(double)); + if (conv == NULL) + { + TIFFErrorExt(tif->tif_clientdata, module, "Out of memory"); + return (0); + } + + switch (tif->tif_dir.td_sampleformat) + { + case SAMPLEFORMAT_IEEEFP: + if (tif->tif_dir.td_bitspersample<=32) + { + for (i = 0; i < count; ++i) + ((float*)conv)[i] = (float)value[i]; + ok = TIFFWriteDirectoryTagFloatArray(tif,ndir,dir,tag,count,(float*)conv); + } + else + { + ok = TIFFWriteDirectoryTagDoubleArray(tif,ndir,dir,tag,count,value); + } + break; + case SAMPLEFORMAT_INT: + if (tif->tif_dir.td_bitspersample<=8) + { + for (i = 0; i < count; ++i) + ((int8*)conv)[i] = (int8)value[i]; + ok = TIFFWriteDirectoryTagSbyteArray(tif,ndir,dir,tag,count,(int8*)conv); + } + else if (tif->tif_dir.td_bitspersample<=16) + { + for (i = 0; i < count; ++i) + ((int16*)conv)[i] = (int16)value[i]; + ok = TIFFWriteDirectoryTagSshortArray(tif,ndir,dir,tag,count,(int16*)conv); + } + else + { + for (i = 0; i < count; ++i) + ((int32*)conv)[i] = (int32)value[i]; + ok = TIFFWriteDirectoryTagSlongArray(tif,ndir,dir,tag,count,(int32*)conv); + } + break; + case SAMPLEFORMAT_UINT: + if (tif->tif_dir.td_bitspersample<=8) + { + for (i = 0; i < count; ++i) + ((uint8*)conv)[i] = (uint8)value[i]; + ok = TIFFWriteDirectoryTagByteArray(tif,ndir,dir,tag,count,(uint8*)conv); + } + else if (tif->tif_dir.td_bitspersample<=16) + { + for (i = 0; i < count; ++i) + ((uint16*)conv)[i] = (uint16)value[i]; + ok = TIFFWriteDirectoryTagShortArray(tif,ndir,dir,tag,count,(uint16*)conv); + } + else + { + for (i = 0; i < count; ++i) + ((uint32*)conv)[i] = (uint32)value[i]; + ok = TIFFWriteDirectoryTagLongArray(tif,ndir,dir,tag,count,(uint32*)conv); + } + break; + default: + ok = 0; + } + + _TIFFfree(conv); + return (ok); } -/* - * Similar to TIFFWriteDirectory(), writes the directory out - * but leaves all data structures in memory so that it can be - * written again. This will make a partially written TIFF file - * readable before it is successfully completed/closed. - */ -int -TIFFCheckpointDirectory(TIFF* tif) +#if 0 +static int +TIFFWriteDirectoryTagSampleformatPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value) { - int rc; - /* Setup the strips arrays, if they haven't already been. */ - if (tif->tif_dir.td_stripoffset == NULL) - (void) TIFFSetupStrips(tif); - rc = _TIFFWriteDirectory(tif, FALSE); - (void) TIFFSetWriteOffset(tif, TIFFSeekFile(tif, 0, SEEK_END)); - return rc; + switch (tif->tif_dir.td_sampleformat) + { + case SAMPLEFORMAT_IEEEFP: + if (tif->tif_dir.td_bitspersample<=32) + return(TIFFWriteDirectoryTagFloatPerSample(tif,ndir,dir,tag,(float)value)); + else + return(TIFFWriteDirectoryTagDoublePerSample(tif,ndir,dir,tag,value)); + case SAMPLEFORMAT_INT: + if (tif->tif_dir.td_bitspersample<=8) + return(TIFFWriteDirectoryTagSbytePerSample(tif,ndir,dir,tag,(int8)value)); + else if (tif->tif_dir.td_bitspersample<=16) + return(TIFFWriteDirectoryTagSshortPerSample(tif,ndir,dir,tag,(int16)value)); + else + return(TIFFWriteDirectoryTagSlongPerSample(tif,ndir,dir,tag,(int32)value)); + case SAMPLEFORMAT_UINT: + if (tif->tif_dir.td_bitspersample<=8) + return(TIFFWriteDirectoryTagBytePerSample(tif,ndir,dir,tag,(uint8)value)); + else if (tif->tif_dir.td_bitspersample<=16) + return(TIFFWriteDirectoryTagShortPerSample(tif,ndir,dir,tag,(uint16)value)); + else + return(TIFFWriteDirectoryTagLongPerSample(tif,ndir,dir,tag,(uint32)value)); + default: + return(1); + } } +#endif static int -_TIFFWriteCustomDirectory(TIFF* tif, toff_t *pdiroff) +TIFFWriteDirectoryTagAscii(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, char* value) { - uint16 dircount; - uint32 nfields; - tsize_t dirsize; - char* data; - TIFFDirEntry* dir; - TIFFDirectory* td; - unsigned long b, fields[FIELD_SETLONGS]; - int fi, nfi; - - if (tif->tif_mode == O_RDONLY) - return (1); + if (dir==NULL) + { + (*ndir)++; + return(1); + } + return(TIFFWriteDirectoryTagCheckedAscii(tif,ndir,dir,tag,count,value)); +} - td = &tif->tif_dir; - /* - * Size the directory so that we can calculate - * offsets for the data items that aren't kept - * in-place in each field. - */ - nfields = 0; - for (b = 0; b <= FIELD_LAST; b++) - if (TIFFFieldSet(tif, b) && b != FIELD_CUSTOM) - nfields += (b < FIELD_SUBFILETYPE ? 2 : 1); - nfields += td->td_customValueCount; - dirsize = nfields * sizeof (TIFFDirEntry); - data = (char*) _TIFFmalloc(dirsize); - if (data == NULL) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Cannot write directory, out of space"); - return (0); +static int +TIFFWriteDirectoryTagUndefinedArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value) +{ + if (dir==NULL) + { + (*ndir)++; + return(1); } - /* - * Put the directory at the end of the file. - */ - tif->tif_diroff = (TIFFSeekFile(tif, (toff_t) 0, SEEK_END)+1) &~ 1; - tif->tif_dataoff = (toff_t)( - tif->tif_diroff + sizeof (uint16) + dirsize + sizeof (toff_t)); - if (tif->tif_dataoff & 1) - tif->tif_dataoff++; - (void) TIFFSeekFile(tif, tif->tif_dataoff, SEEK_SET); - dir = (TIFFDirEntry*) data; - /* - * Setup external form of directory - * entries and write data items. - */ - _TIFFmemcpy(fields, td->td_fieldsset, sizeof (fields)); + return(TIFFWriteDirectoryTagCheckedUndefinedArray(tif,ndir,dir,tag,count,value)); +} - for (fi = 0, nfi = tif->tif_nfields; nfi > 0; nfi--, fi++) { - const TIFFFieldInfo* fip = tif->tif_fieldinfo[fi]; +#ifdef notdef +static int +TIFFWriteDirectoryTagByte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint8 value) +{ + if (dir==NULL) + { + (*ndir)++; + return(1); + } + return(TIFFWriteDirectoryTagCheckedByte(tif,ndir,dir,tag,value)); +} +#endif - /* - * For custom fields, we test to see if the custom field - * is set or not. For normal fields, we just use the - * FieldSet test. - */ - if( fip->field_bit == FIELD_CUSTOM ) - { - int ci, is_set = FALSE; +static int +TIFFWriteDirectoryTagByteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value) +{ + if (dir==NULL) + { + (*ndir)++; + return(1); + } + return(TIFFWriteDirectoryTagCheckedByteArray(tif,ndir,dir,tag,count,value)); +} - for( ci = 0; ci < td->td_customValueCount; ci++ ) - is_set |= (td->td_customValues[ci].info == fip); +#if 0 +static int +TIFFWriteDirectoryTagBytePerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint8 value) +{ + static const char module[] = "TIFFWriteDirectoryTagBytePerSample"; + uint8* m; + uint8* na; + uint16 nb; + int o; + if (dir==NULL) + { + (*ndir)++; + return(1); + } + m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(uint8)); + if (m==NULL) + { + TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); + return(0); + } + for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++) + *na=value; + o=TIFFWriteDirectoryTagCheckedByteArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m); + _TIFFfree(m); + return(o); +} +#endif - if( !is_set ) - continue; - } - else if (!FieldSet(fields, fip->field_bit)) - continue; - - if( fip->field_bit != FIELD_CUSTOM ) - ResetFieldBit(fields, fip->field_bit); +#ifdef notdef +static int +TIFFWriteDirectoryTagSbyte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int8 value) +{ + if (dir==NULL) + { + (*ndir)++; + return(1); } + return(TIFFWriteDirectoryTagCheckedSbyte(tif,ndir,dir,tag,value)); +} +#endif - /* - * Write directory. - */ - dircount = (uint16) nfields; - *pdiroff = (uint32) tif->tif_nextdiroff; - if (tif->tif_flags & TIFF_SWAB) { - /* - * The file's byte order is opposite to the - * native machine architecture. We overwrite - * the directory information with impunity - * because it'll be released below after we - * write it to the file. Note that all the - * other tag construction routines assume that - * we do this byte-swapping; i.e. they only - * byte-swap indirect data. - */ - for (dir = (TIFFDirEntry*) data; dircount; dir++, dircount--) { - TIFFSwabArrayOfShort(&dir->tdir_tag, 2); - TIFFSwabArrayOfLong(&dir->tdir_count, 2); - } - dircount = (uint16) nfields; - TIFFSwabShort(&dircount); - TIFFSwabLong(pdiroff); - } - (void) TIFFSeekFile(tif, tif->tif_diroff, SEEK_SET); - if (!WriteOK(tif, &dircount, sizeof (dircount))) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Error writing directory count"); - goto bad; +static int +TIFFWriteDirectoryTagSbyteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int8* value) +{ + if (dir==NULL) + { + (*ndir)++; + return(1); } - if (!WriteOK(tif, data, dirsize)) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Error writing directory contents"); - goto bad; + return(TIFFWriteDirectoryTagCheckedSbyteArray(tif,ndir,dir,tag,count,value)); +} + +#if 0 +static int +TIFFWriteDirectoryTagSbytePerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int8 value) +{ + static const char module[] = "TIFFWriteDirectoryTagSbytePerSample"; + int8* m; + int8* na; + uint16 nb; + int o; + if (dir==NULL) + { + (*ndir)++; + return(1); } - if (!WriteOK(tif, pdiroff, sizeof (uint32))) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Error writing directory link"); - goto bad; + m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(int8)); + if (m==NULL) + { + TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); + return(0); } - _TIFFfree(data); - return (1); -bad: - _TIFFfree(data); - return (0); + for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++) + *na=value; + o=TIFFWriteDirectoryTagCheckedSbyteArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m); + _TIFFfree(m); + return(o); } +#endif -int -TIFFWriteCustomDirectory(TIFF* tif, toff_t *pdiroff) +static int +TIFFWriteDirectoryTagShort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 value) { - return _TIFFWriteCustomDirectory(tif, pdiroff); + if (dir==NULL) + { + (*ndir)++; + return(1); + } + return(TIFFWriteDirectoryTagCheckedShort(tif,ndir,dir,tag,value)); } -/* - * Process tags that are not special cased. - */ static int -TIFFWriteNormalTag(TIFF* tif, TIFFDirEntry* dir, const TIFFFieldInfo* fip) -{ - uint16 wc = (uint16) fip->field_writecount; - uint32 wc2; - - dir->tdir_tag = (uint16) fip->field_tag; - dir->tdir_type = (uint16) fip->field_type; - dir->tdir_count = wc; - - switch (fip->field_type) { - case TIFF_SHORT: - case TIFF_SSHORT: - if (fip->field_passcount) { - uint16* wp; - if (wc == (uint16) TIFF_VARIABLE2) { - TIFFGetField(tif, fip->field_tag, &wc2, &wp); - dir->tdir_count = wc2; - } else { /* Assume TIFF_VARIABLE */ - TIFFGetField(tif, fip->field_tag, &wc, &wp); - dir->tdir_count = wc; - } - if (!TIFFWriteShortArray(tif, dir, wp)) - return 0; - } else { - if (wc == 1) { - uint16 sv; - TIFFGetField(tif, fip->field_tag, &sv); - dir->tdir_offset = - TIFFInsertData(tif, dir->tdir_type, sv); - } else { - uint16* wp; - TIFFGetField(tif, fip->field_tag, &wp); - if (!TIFFWriteShortArray(tif, dir, wp)) - return 0; - } - } - break; - case TIFF_LONG: - case TIFF_SLONG: - case TIFF_IFD: - if (fip->field_passcount) { - uint32* lp; - if (wc == (uint16) TIFF_VARIABLE2) { - TIFFGetField(tif, fip->field_tag, &wc2, &lp); - dir->tdir_count = wc2; - } else { /* Assume TIFF_VARIABLE */ - TIFFGetField(tif, fip->field_tag, &wc, &lp); - dir->tdir_count = wc; - } - if (!TIFFWriteLongArray(tif, dir, lp)) - return 0; - } else { - if (wc == 1) { - /* XXX handle LONG->SHORT conversion */ - TIFFGetField(tif, fip->field_tag, - &dir->tdir_offset); - } else { - uint32* lp; - TIFFGetField(tif, fip->field_tag, &lp); - if (!TIFFWriteLongArray(tif, dir, lp)) - return 0; - } - } - break; - case TIFF_RATIONAL: - case TIFF_SRATIONAL: - if (fip->field_passcount) { - float* fp; - if (wc == (uint16) TIFF_VARIABLE2) { - TIFFGetField(tif, fip->field_tag, &wc2, &fp); - dir->tdir_count = wc2; - } else { /* Assume TIFF_VARIABLE */ - TIFFGetField(tif, fip->field_tag, &wc, &fp); - dir->tdir_count = wc; - } - if (!TIFFWriteRationalArray(tif, dir, fp)) - return 0; - } else { - if (wc == 1) { - float fv; - TIFFGetField(tif, fip->field_tag, &fv); - if (!TIFFWriteRationalArray(tif, dir, &fv)) - return 0; - } else { - float* fp; - TIFFGetField(tif, fip->field_tag, &fp); - if (!TIFFWriteRationalArray(tif, dir, fp)) - return 0; - } - } - break; - case TIFF_FLOAT: - if (fip->field_passcount) { - float* fp; - if (wc == (uint16) TIFF_VARIABLE2) { - TIFFGetField(tif, fip->field_tag, &wc2, &fp); - dir->tdir_count = wc2; - } else { /* Assume TIFF_VARIABLE */ - TIFFGetField(tif, fip->field_tag, &wc, &fp); - dir->tdir_count = wc; - } - if (!TIFFWriteFloatArray(tif, dir, fp)) - return 0; - } else { - if (wc == 1) { - float fv; - TIFFGetField(tif, fip->field_tag, &fv); - if (!TIFFWriteFloatArray(tif, dir, &fv)) - return 0; - } else { - float* fp; - TIFFGetField(tif, fip->field_tag, &fp); - if (!TIFFWriteFloatArray(tif, dir, fp)) - return 0; - } - } - break; - case TIFF_DOUBLE: - if (fip->field_passcount) { - double* dp; - if (wc == (uint16) TIFF_VARIABLE2) { - TIFFGetField(tif, fip->field_tag, &wc2, &dp); - dir->tdir_count = wc2; - } else { /* Assume TIFF_VARIABLE */ - TIFFGetField(tif, fip->field_tag, &wc, &dp); - dir->tdir_count = wc; - } - if (!TIFFWriteDoubleArray(tif, dir, dp)) - return 0; - } else { - if (wc == 1) { - double dv; - TIFFGetField(tif, fip->field_tag, &dv); - if (!TIFFWriteDoubleArray(tif, dir, &dv)) - return 0; - } else { - double* dp; - TIFFGetField(tif, fip->field_tag, &dp); - if (!TIFFWriteDoubleArray(tif, dir, dp)) - return 0; - } - } - break; - case TIFF_ASCII: - { - char* cp; - if (fip->field_passcount) - { - if( wc == (uint16) TIFF_VARIABLE2 ) - TIFFGetField(tif, fip->field_tag, &wc2, &cp); - else - TIFFGetField(tif, fip->field_tag, &wc, &cp); - } - else - TIFFGetField(tif, fip->field_tag, &cp); +TIFFWriteDirectoryTagShortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint16* value) +{ + if (dir==NULL) + { + (*ndir)++; + return(1); + } + return(TIFFWriteDirectoryTagCheckedShortArray(tif,ndir,dir,tag,count,value)); +} - dir->tdir_count = (uint32) (strlen(cp) + 1); - if (!TIFFWriteByteArray(tif, dir, cp)) - return (0); - } - break; - - case TIFF_BYTE: - case TIFF_SBYTE: - if (fip->field_passcount) { - char* cp; - if (wc == (uint16) TIFF_VARIABLE2) { - TIFFGetField(tif, fip->field_tag, &wc2, &cp); - dir->tdir_count = wc2; - } else { /* Assume TIFF_VARIABLE */ - TIFFGetField(tif, fip->field_tag, &wc, &cp); - dir->tdir_count = wc; - } - if (!TIFFWriteByteArray(tif, dir, cp)) - return 0; - } else { - if (wc == 1) { - char cv; - TIFFGetField(tif, fip->field_tag, &cv); - if (!TIFFWriteByteArray(tif, dir, &cv)) - return 0; - } else { - char* cp; - TIFFGetField(tif, fip->field_tag, &cp); - if (!TIFFWriteByteArray(tif, dir, cp)) - return 0; - } - } - break; - - case TIFF_UNDEFINED: - { char* cp; - if (wc == (unsigned short) TIFF_VARIABLE) { - TIFFGetField(tif, fip->field_tag, &wc, &cp); - dir->tdir_count = wc; - } else if (wc == (unsigned short) TIFF_VARIABLE2) { - TIFFGetField(tif, fip->field_tag, &wc2, &cp); - dir->tdir_count = wc2; - } else - TIFFGetField(tif, fip->field_tag, &cp); - if (!TIFFWriteByteArray(tif, dir, cp)) - return (0); - } - break; +static int +TIFFWriteDirectoryTagShortPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 value) +{ + static const char module[] = "TIFFWriteDirectoryTagShortPerSample"; + uint16* m; + uint16* na; + uint16 nb; + int o; + if (dir==NULL) + { + (*ndir)++; + return(1); + } + m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(uint16)); + if (m==NULL) + { + TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); + return(0); + } + for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++) + *na=value; + o=TIFFWriteDirectoryTagCheckedShortArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m); + _TIFFfree(m); + return(o); +} - case TIFF_NOTYPE: - break; +#ifdef notdef +static int +TIFFWriteDirectoryTagSshort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int16 value) +{ + if (dir==NULL) + { + (*ndir)++; + return(1); } - return (1); + return(TIFFWriteDirectoryTagCheckedSshort(tif,ndir,dir,tag,value)); } +#endif -/* - * Setup a directory entry with either a SHORT - * or LONG type according to the value. - */ -static void -TIFFSetupShortLong(TIFF* tif, ttag_t tag, TIFFDirEntry* dir, uint32 v) +static int +TIFFWriteDirectoryTagSshortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int16* value) { - dir->tdir_tag = (uint16) tag; - dir->tdir_count = 1; - if (v > 0xffffL) { - dir->tdir_type = (short) TIFF_LONG; - dir->tdir_offset = v; - } else { - dir->tdir_type = (short) TIFF_SHORT; - dir->tdir_offset = TIFFInsertData(tif, (int) TIFF_SHORT, v); + if (dir==NULL) + { + (*ndir)++; + return(1); } + return(TIFFWriteDirectoryTagCheckedSshortArray(tif,ndir,dir,tag,count,value)); } -/* - * Setup a SHORT directory entry - */ -static void -TIFFSetupShort(TIFF* tif, ttag_t tag, TIFFDirEntry* dir, uint16 v) +#if 0 +static int +TIFFWriteDirectoryTagSshortPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int16 value) { - dir->tdir_tag = (uint16) tag; - dir->tdir_count = 1; - dir->tdir_type = (short) TIFF_SHORT; - dir->tdir_offset = TIFFInsertData(tif, (int) TIFF_SHORT, v); + static const char module[] = "TIFFWriteDirectoryTagSshortPerSample"; + int16* m; + int16* na; + uint16 nb; + int o; + if (dir==NULL) + { + (*ndir)++; + return(1); + } + m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(int16)); + if (m==NULL) + { + TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); + return(0); + } + for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++) + *na=value; + o=TIFFWriteDirectoryTagCheckedSshortArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m); + _TIFFfree(m); + return(o); } -#undef MakeShortDirent +#endif -#define NITEMS(x) (sizeof (x) / sizeof (x[0])) -/* - * Setup a directory entry that references a - * samples/pixel array of SHORT values and - * (potentially) write the associated indirect - * values. - */ static int -TIFFWritePerSampleShorts(TIFF* tif, ttag_t tag, TIFFDirEntry* dir) +TIFFWriteDirectoryTagLong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value) { - uint16 buf[10], v; - uint16* w = buf; - uint16 i, samples = tif->tif_dir.td_samplesperpixel; - int status; + if (dir==NULL) + { + (*ndir)++; + return(1); + } + return(TIFFWriteDirectoryTagCheckedLong(tif,ndir,dir,tag,value)); +} - if (samples > NITEMS(buf)) { - w = (uint16*) _TIFFmalloc(samples * sizeof (uint16)); - if (w == NULL) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "No space to write per-sample shorts"); - return (0); - } +static int +TIFFWriteDirectoryTagLongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value) +{ + if (dir==NULL) + { + (*ndir)++; + return(1); } - TIFFGetField(tif, tag, &v); - for (i = 0; i < samples; i++) - w[i] = v; - - dir->tdir_tag = (uint16) tag; - dir->tdir_type = (uint16) TIFF_SHORT; - dir->tdir_count = samples; - status = TIFFWriteShortArray(tif, dir, w); - if (w != buf) - _TIFFfree((char*) w); - return (status); + return(TIFFWriteDirectoryTagCheckedLongArray(tif,ndir,dir,tag,count,value)); } -/* - * Setup a directory entry that references a samples/pixel array of ``type'' - * values and (potentially) write the associated indirect values. The source - * data from TIFFGetField() for the specified tag must be returned as double. - */ +#if 0 static int -TIFFWritePerSampleAnys(TIFF* tif, - TIFFDataType type, ttag_t tag, TIFFDirEntry* dir) +TIFFWriteDirectoryTagLongPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value) { - double buf[10], v; - double* w = buf; - uint16 i, samples = tif->tif_dir.td_samplesperpixel; - int status; + static const char module[] = "TIFFWriteDirectoryTagLongPerSample"; + uint32* m; + uint32* na; + uint16 nb; + int o; + if (dir==NULL) + { + (*ndir)++; + return(1); + } + m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(uint32)); + if (m==NULL) + { + TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); + return(0); + } + for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++) + *na=value; + o=TIFFWriteDirectoryTagCheckedLongArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m); + _TIFFfree(m); + return(o); +} +#endif - if (samples > NITEMS(buf)) { - w = (double*) _TIFFmalloc(samples * sizeof (double)); - if (w == NULL) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "No space to write per-sample values"); - return (0); - } +#ifdef notdef +static int +TIFFWriteDirectoryTagSlong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int32 value) +{ + if (dir==NULL) + { + (*ndir)++; + return(1); } - TIFFGetField(tif, tag, &v); - for (i = 0; i < samples; i++) - w[i] = v; - status = TIFFWriteAnyArray(tif, type, tag, dir, samples, w); - if (w != buf) - _TIFFfree(w); - return (status); + return(TIFFWriteDirectoryTagCheckedSlong(tif,ndir,dir,tag,value)); } -#undef NITEMS +#endif -/* - * Setup a pair of shorts that are returned by - * value, rather than as a reference to an array. - */ static int -TIFFSetupShortPair(TIFF* tif, ttag_t tag, TIFFDirEntry* dir) +TIFFWriteDirectoryTagSlongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int32* value) { - uint16 v[2]; + if (dir==NULL) + { + (*ndir)++; + return(1); + } + return(TIFFWriteDirectoryTagCheckedSlongArray(tif,ndir,dir,tag,count,value)); +} - TIFFGetField(tif, tag, &v[0], &v[1]); +#if 0 +static int +TIFFWriteDirectoryTagSlongPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int32 value) +{ + static const char module[] = "TIFFWriteDirectoryTagSlongPerSample"; + int32* m; + int32* na; + uint16 nb; + int o; + if (dir==NULL) + { + (*ndir)++; + return(1); + } + m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(int32)); + if (m==NULL) + { + TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); + return(0); + } + for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++) + *na=value; + o=TIFFWriteDirectoryTagCheckedSlongArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m); + _TIFFfree(m); + return(o); +} +#endif - dir->tdir_tag = (uint16) tag; - dir->tdir_type = (uint16) TIFF_SHORT; - dir->tdir_count = 2; - return (TIFFWriteShortArray(tif, dir, v)); +#ifdef notdef +static int +TIFFWriteDirectoryTagLong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint64 value) +{ + if (dir==NULL) + { + (*ndir)++; + return(1); + } + return(TIFFWriteDirectoryTagCheckedLong8(tif,ndir,dir,tag,value)); } +#endif -/* - * Setup a directory entry for an NxM table of shorts, - * where M is known to be 2**bitspersample, and write - * the associated indirect data. - */ static int -TIFFWriteShortTable(TIFF* tif, - ttag_t tag, TIFFDirEntry* dir, uint32 n, uint16** table) +TIFFWriteDirectoryTagLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value) { - uint32 i, off; + if (dir==NULL) + { + (*ndir)++; + return(1); + } + return(TIFFWriteDirectoryTagCheckedLong8Array(tif,ndir,dir,tag,count,value)); +} - dir->tdir_tag = (uint16) tag; - dir->tdir_type = (short) TIFF_SHORT; - /* XXX -- yech, fool TIFFWriteData */ - dir->tdir_count = (uint32) (1L<<tif->tif_dir.td_bitspersample); - off = tif->tif_dataoff; - for (i = 0; i < n; i++) - if (!TIFFWriteData(tif, dir, (char *)table[i])) - return (0); - dir->tdir_count *= n; - dir->tdir_offset = off; - return (1); +#ifdef notdef +static int +TIFFWriteDirectoryTagSlong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int64 value) +{ + if (dir==NULL) + { + (*ndir)++; + return(1); + } + return(TIFFWriteDirectoryTagCheckedSlong8(tif,ndir,dir,tag,value)); } +#endif -/* - * Write/copy data associated with an ASCII or opaque tag value. - */ static int -TIFFWriteByteArray(TIFF* tif, TIFFDirEntry* dir, char* cp) -{ - if (dir->tdir_count <= 4) { - if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) { - dir->tdir_offset = (uint32)cp[0] << 24; - if (dir->tdir_count >= 2) - dir->tdir_offset |= (uint32)cp[1] << 16; - if (dir->tdir_count >= 3) - dir->tdir_offset |= (uint32)cp[2] << 8; - if (dir->tdir_count == 4) - dir->tdir_offset |= cp[3]; - } else { - dir->tdir_offset = cp[0]; - if (dir->tdir_count >= 2) - dir->tdir_offset |= (uint32) cp[1] << 8; - if (dir->tdir_count >= 3) - dir->tdir_offset |= (uint32) cp[2] << 16; - if (dir->tdir_count == 4) - dir->tdir_offset |= (uint32) cp[3] << 24; - } - return 1; - } else - return TIFFWriteData(tif, dir, cp); +TIFFWriteDirectoryTagSlong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int64* value) +{ + if (dir==NULL) + { + (*ndir)++; + return(1); + } + return(TIFFWriteDirectoryTagCheckedSlong8Array(tif,ndir,dir,tag,count,value)); } -/* - * Setup a directory entry of an array of SHORT - * or SSHORT and write the associated indirect values. - */ static int -TIFFWriteShortArray(TIFF* tif, TIFFDirEntry* dir, uint16* v) -{ - if (dir->tdir_count <= 2) { - if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) { - dir->tdir_offset = (uint32) v[0] << 16; - if (dir->tdir_count == 2) - dir->tdir_offset |= v[1] & 0xffff; - } else { - dir->tdir_offset = v[0] & 0xffff; - if (dir->tdir_count == 2) - dir->tdir_offset |= (uint32) v[1] << 16; - } - return (1); - } else - return (TIFFWriteData(tif, dir, (char*) v)); +TIFFWriteDirectoryTagRational(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value) +{ + if (dir==NULL) + { + (*ndir)++; + return(1); + } + return(TIFFWriteDirectoryTagCheckedRational(tif,ndir,dir,tag,value)); } -/* - * Setup a directory entry of an array of LONG - * or SLONG and write the associated indirect values. - */ static int -TIFFWriteLongArray(TIFF* tif, TIFFDirEntry* dir, uint32* v) +TIFFWriteDirectoryTagRationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value) { - if (dir->tdir_count == 1) { - dir->tdir_offset = v[0]; - return (1); - } else - return (TIFFWriteData(tif, dir, (char*) v)); + if (dir==NULL) + { + (*ndir)++; + return(1); + } + return(TIFFWriteDirectoryTagCheckedRationalArray(tif,ndir,dir,tag,count,value)); } -/* - * Setup a directory entry of an array of RATIONAL - * or SRATIONAL and write the associated indirect values. - */ static int -TIFFWriteRationalArray(TIFF* tif, TIFFDirEntry* dir, float* v) +TIFFWriteDirectoryTagSrationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value) { - uint32 i; - uint32* t; - int status; + if (dir==NULL) + { + (*ndir)++; + return(1); + } + return(TIFFWriteDirectoryTagCheckedSrationalArray(tif,ndir,dir,tag,count,value)); +} - t = (uint32*) _TIFFmalloc(2 * dir->tdir_count * sizeof (uint32)); - if (t == NULL) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "No space to write RATIONAL array"); - return (0); +#ifdef notdef +static int TIFFWriteDirectoryTagFloat(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, float value) +{ + if (dir==NULL) + { + (*ndir)++; + return(1); } - for (i = 0; i < dir->tdir_count; i++) { - float fv = v[i]; - int sign = 1; - uint32 den; - - if (fv < 0) { - if (dir->tdir_type == TIFF_RATIONAL) { - TIFFWarningExt(tif->tif_clientdata, - tif->tif_name, - "\"%s\": Information lost writing value (%g) as (unsigned) RATIONAL", - _TIFFFieldWithTag(tif,dir->tdir_tag)->field_name, - fv); - fv = 0; - } else - fv = -fv, sign = -1; - } - den = 1L; - if (fv > 0) { - while (fv < 1L<<(31-3) && den < 1L<<(31-3)) - fv *= 1<<3, den *= 1L<<3; - } - t[2*i+0] = (uint32) (sign * (fv + 0.5)); - t[2*i+1] = den; + return(TIFFWriteDirectoryTagCheckedFloat(tif,ndir,dir,tag,value)); +} +#endif + +static int TIFFWriteDirectoryTagFloatArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value) +{ + if (dir==NULL) + { + (*ndir)++; + return(1); } - status = TIFFWriteData(tif, dir, (char *)t); - _TIFFfree((char*) t); - return (status); + return(TIFFWriteDirectoryTagCheckedFloatArray(tif,ndir,dir,tag,count,value)); } -static int -TIFFWriteFloatArray(TIFF* tif, TIFFDirEntry* dir, float* v) +#if 0 +static int TIFFWriteDirectoryTagFloatPerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, float value) { - TIFFCvtNativeToIEEEFloat(tif, dir->tdir_count, v); - if (dir->tdir_count == 1) { - dir->tdir_offset = *(uint32*) &v[0]; - return (1); - } else - return (TIFFWriteData(tif, dir, (char*) v)); + static const char module[] = "TIFFWriteDirectoryTagFloatPerSample"; + float* m; + float* na; + uint16 nb; + int o; + if (dir==NULL) + { + (*ndir)++; + return(1); + } + m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(float)); + if (m==NULL) + { + TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); + return(0); + } + for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++) + *na=value; + o=TIFFWriteDirectoryTagCheckedFloatArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m); + _TIFFfree(m); + return(o); +} +#endif + +#ifdef notdef +static int TIFFWriteDirectoryTagDouble(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value) +{ + if (dir==NULL) + { + (*ndir)++; + return(1); + } + return(TIFFWriteDirectoryTagCheckedDouble(tif,ndir,dir,tag,value)); +} +#endif + +static int TIFFWriteDirectoryTagDoubleArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, double* value) +{ + if (dir==NULL) + { + (*ndir)++; + return(1); + } + return(TIFFWriteDirectoryTagCheckedDoubleArray(tif,ndir,dir,tag,count,value)); } +#if 0 +static int TIFFWriteDirectoryTagDoublePerSample(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value) +{ + static const char module[] = "TIFFWriteDirectoryTagDoublePerSample"; + double* m; + double* na; + uint16 nb; + int o; + if (dir==NULL) + { + (*ndir)++; + return(1); + } + m=_TIFFmalloc(tif->tif_dir.td_samplesperpixel*sizeof(double)); + if (m==NULL) + { + TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); + return(0); + } + for (na=m, nb=0; nb<tif->tif_dir.td_samplesperpixel; na++, nb++) + *na=value; + o=TIFFWriteDirectoryTagCheckedDoubleArray(tif,ndir,dir,tag,tif->tif_dir.td_samplesperpixel,m); + _TIFFfree(m); + return(o); +} +#endif + static int -TIFFWriteDoubleArray(TIFF* tif, TIFFDirEntry* dir, double* v) +TIFFWriteDirectoryTagIfdArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value) { - TIFFCvtNativeToIEEEDouble(tif, dir->tdir_count, v); - return (TIFFWriteData(tif, dir, (char*) v)); + if (dir==NULL) + { + (*ndir)++; + return(1); + } + return(TIFFWriteDirectoryTagCheckedIfdArray(tif,ndir,dir,tag,count,value)); } -/* - * Write an array of ``type'' values for a specified tag (i.e. this is a tag - * which is allowed to have different types, e.g. SMaxSampleType). - * Internally the data values are represented as double since a double can - * hold any of the TIFF tag types (yes, this should really be an abstract - * type tany_t for portability). The data is converted into the specified - * type in a temporary buffer and then handed off to the appropriate array - * writer. - */ +#ifdef notdef static int -TIFFWriteAnyArray(TIFF* tif, - TIFFDataType type, ttag_t tag, TIFFDirEntry* dir, uint32 n, double* v) +TIFFWriteDirectoryTagIfd8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value) { - char buf[10 * sizeof(double)]; - char* w = buf; - int i, status = 0; + if (dir==NULL) + { + (*ndir)++; + return(1); + } + return(TIFFWriteDirectoryTagCheckedIfd8Array(tif,ndir,dir,tag,count,value)); +} +#endif - if (n * TIFFDataWidth(type) > sizeof buf) { - w = (char*) _TIFFmalloc(n * TIFFDataWidth(type)); - if (w == NULL) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "No space to write array"); - return (0); - } +static int +TIFFWriteDirectoryTagShortLong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value) +{ + if (dir==NULL) + { + (*ndir)++; + return(1); } + if (value<=0xFFFF) + return(TIFFWriteDirectoryTagCheckedShort(tif,ndir,dir,tag,(uint16)value)); + else + return(TIFFWriteDirectoryTagCheckedLong(tif,ndir,dir,tag,value)); +} - dir->tdir_tag = (uint16) tag; - dir->tdir_type = (uint16) type; - dir->tdir_count = n; +/************************************************************************/ +/* TIFFWriteDirectoryTagLongLong8Array() */ +/* */ +/* Write out LONG8 array as LONG8 for BigTIFF or LONG for */ +/* Classic TIFF with some checking. */ +/************************************************************************/ - switch (type) { - case TIFF_BYTE: - { - uint8* bp = (uint8*) w; - for (i = 0; i < (int) n; i++) - bp[i] = (uint8) v[i]; - if (!TIFFWriteByteArray(tif, dir, (char*) bp)) - goto out; - } - break; - case TIFF_SBYTE: - { - int8* bp = (int8*) w; - for (i = 0; i < (int) n; i++) - bp[i] = (int8) v[i]; - if (!TIFFWriteByteArray(tif, dir, (char*) bp)) - goto out; - } - break; - case TIFF_SHORT: +static int +TIFFWriteDirectoryTagLongLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value) +{ + static const char module[] = "TIFFWriteDirectoryTagLongLong8Array"; + uint64* ma; + uint32 mb; + uint32* p; + uint32* q; + int o; + + /* is this just a counting pass? */ + if (dir==NULL) + { + (*ndir)++; + return(1); + } + + /* We always write LONG8 for BigTIFF, no checking needed. */ + if( tif->tif_flags&TIFF_BIGTIFF ) + return TIFFWriteDirectoryTagCheckedLong8Array(tif,ndir,dir, + tag,count,value); + + /* + ** For classic tiff we want to verify everything is in range for LONG + ** and convert to long format. + */ + + p = _TIFFmalloc(count*sizeof(uint32)); + if (p==NULL) + { + TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); + return(0); + } + + for (q=p, ma=value, mb=0; mb<count; ma++, mb++, q++) + { + if (*ma>0xFFFFFFFF) + { + TIFFErrorExt(tif->tif_clientdata,module, + "Attempt to write value larger than 0xFFFFFFFF in Classic TIFF file."); + _TIFFfree(p); + return(0); + } + *q= (uint32)(*ma); + } + + o=TIFFWriteDirectoryTagCheckedLongArray(tif,ndir,dir,tag,count,p); + _TIFFfree(p); + + return(o); +} + +/************************************************************************/ +/* TIFFWriteDirectoryTagIfdIfd8Array() */ +/* */ +/* Write either IFD8 or IFD array depending on file type. */ +/************************************************************************/ + +static int +TIFFWriteDirectoryTagIfdIfd8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value) +{ + static const char module[] = "TIFFWriteDirectoryTagIfdIfd8Array"; + uint64* ma; + uint32 mb; + uint32* p; + uint32* q; + int o; + + /* is this just a counting pass? */ + if (dir==NULL) + { + (*ndir)++; + return(1); + } + + /* We always write IFD8 for BigTIFF, no checking needed. */ + if( tif->tif_flags&TIFF_BIGTIFF ) + return TIFFWriteDirectoryTagCheckedIfd8Array(tif,ndir,dir, + tag,count,value); + + /* + ** For classic tiff we want to verify everything is in range for IFD + ** and convert to long format. + */ + + p = _TIFFmalloc(count*sizeof(uint32)); + if (p==NULL) + { + TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); + return(0); + } + + for (q=p, ma=value, mb=0; mb<count; ma++, mb++, q++) + { + if (*ma>0xFFFFFFFF) + { + TIFFErrorExt(tif->tif_clientdata,module, + "Attempt to write value larger than 0xFFFFFFFF in Classic TIFF file."); + _TIFFfree(p); + return(0); + } + *q= (uint32)(*ma); + } + + o=TIFFWriteDirectoryTagCheckedIfdArray(tif,ndir,dir,tag,count,p); + _TIFFfree(p); + + return(o); +} + +#ifdef notdef +static int +TIFFWriteDirectoryTagShortLongLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value) +{ + static const char module[] = "TIFFWriteDirectoryTagShortLongLong8Array"; + uint64* ma; + uint32 mb; + uint8 n; + int o; + if (dir==NULL) + { + (*ndir)++; + return(1); + } + n=0; + for (ma=value, mb=0; mb<count; ma++, mb++) + { + if ((n==0)&&(*ma>0xFFFF)) + n=1; + if ((n==1)&&(*ma>0xFFFFFFFF)) { - uint16* bp = (uint16*) w; - for (i = 0; i < (int) n; i++) - bp[i] = (uint16) v[i]; - if (!TIFFWriteShortArray(tif, dir, (uint16*)bp)) - goto out; - } - break; - case TIFF_SSHORT: - { - int16* bp = (int16*) w; - for (i = 0; i < (int) n; i++) - bp[i] = (int16) v[i]; - if (!TIFFWriteShortArray(tif, dir, (uint16*)bp)) - goto out; + n=2; + break; } - break; - case TIFF_LONG: + } + if (n==0) + { + uint16* p; + uint16* q; + p=_TIFFmalloc(count*sizeof(uint16)); + if (p==NULL) { - uint32* bp = (uint32*) w; - for (i = 0; i < (int) n; i++) - bp[i] = (uint32) v[i]; - if (!TIFFWriteLongArray(tif, dir, bp)) - goto out; + TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); + return(0); } - break; - case TIFF_SLONG: + for (ma=value, mb=0, q=p; mb<count; ma++, mb++, q++) + *q=(uint16)(*ma); + o=TIFFWriteDirectoryTagCheckedShortArray(tif,ndir,dir,tag,count,p); + _TIFFfree(p); + } + else if (n==1) + { + uint32* p; + uint32* q; + p=_TIFFmalloc(count*sizeof(uint32)); + if (p==NULL) { - int32* bp = (int32*) w; - for (i = 0; i < (int) n; i++) - bp[i] = (int32) v[i]; - if (!TIFFWriteLongArray(tif, dir, (uint32*) bp)) - goto out; - } - break; - case TIFF_FLOAT: - { - float* bp = (float*) w; - for (i = 0; i < (int) n; i++) - bp[i] = (float) v[i]; - if (!TIFFWriteFloatArray(tif, dir, bp)) - goto out; + TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); + return(0); } - break; - case TIFF_DOUBLE: - { - if( !TIFFWriteDoubleArray(tif, dir, v)) - goto out; - } - break; - default: - /* TIFF_NOTYPE */ - /* TIFF_ASCII */ - /* TIFF_UNDEFINED */ - /* TIFF_RATIONAL */ - /* TIFF_SRATIONAL */ - goto out; - } - status = 1; - out: - if (w != buf) - _TIFFfree(w); - return (status); -} - -static int -TIFFWriteTransferFunction(TIFF* tif, TIFFDirEntry* dir) -{ - TIFFDirectory* td = &tif->tif_dir; - tsize_t n = (1L<<td->td_bitspersample) * sizeof (uint16); - uint16** tf = td->td_transferfunction; - int ncols; + for (ma=value, mb=0, q=p; mb<count; ma++, mb++, q++) + *q=(uint32)(*ma); + o=TIFFWriteDirectoryTagCheckedLongArray(tif,ndir,dir,tag,count,p); + _TIFFfree(p); + } + else + { + assert(n==2); + o=TIFFWriteDirectoryTagCheckedLong8Array(tif,ndir,dir,tag,count,value); + } + return(o); +} +#endif +static int +TIFFWriteDirectoryTagColormap(TIFF* tif, uint32* ndir, TIFFDirEntry* dir) +{ + static const char module[] = "TIFFWriteDirectoryTagColormap"; + uint32 m; + uint16* n; + int o; + if (dir==NULL) + { + (*ndir)++; + return(1); + } + m=(1<<tif->tif_dir.td_bitspersample); + n=_TIFFmalloc(3*m*sizeof(uint16)); + if (n==NULL) + { + TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); + return(0); + } + _TIFFmemcpy(&n[0],tif->tif_dir.td_colormap[0],m*sizeof(uint16)); + _TIFFmemcpy(&n[m],tif->tif_dir.td_colormap[1],m*sizeof(uint16)); + _TIFFmemcpy(&n[2*m],tif->tif_dir.td_colormap[2],m*sizeof(uint16)); + o=TIFFWriteDirectoryTagCheckedShortArray(tif,ndir,dir,TIFFTAG_COLORMAP,3*m,n); + _TIFFfree(n); + return(o); +} +static int +TIFFWriteDirectoryTagTransferfunction(TIFF* tif, uint32* ndir, TIFFDirEntry* dir) +{ + static const char module[] = "TIFFWriteDirectoryTagTransferfunction"; + uint32 m; + uint16 n; + uint16* o; + int p; + if (dir==NULL) + { + (*ndir)++; + return(1); + } + m=(1<<tif->tif_dir.td_bitspersample); + n=tif->tif_dir.td_samplesperpixel-tif->tif_dir.td_extrasamples; /* * Check if the table can be written as a single column, * or if it must be written as 3 columns. Note that we * write a 3-column tag if there are 2 samples/pixel and * a single column of data won't suffice--hmm. */ - switch (td->td_samplesperpixel - td->td_extrasamples) { - default: if (_TIFFmemcmp(tf[0], tf[2], n)) { ncols = 3; break; } - case 2: if (_TIFFmemcmp(tf[0], tf[1], n)) { ncols = 3; break; } - case 1: case 0: ncols = 1; + if (n>3) + n=3; + if (n==3) + { + if (!_TIFFmemcmp(tif->tif_dir.td_transferfunction[0],tif->tif_dir.td_transferfunction[2],m*sizeof(uint16))) + n=2; + } + if (n==2) + { + if (!_TIFFmemcmp(tif->tif_dir.td_transferfunction[0],tif->tif_dir.td_transferfunction[1],m*sizeof(uint16))) + n=1; + } + if (n==0) + n=1; + o=_TIFFmalloc(n*m*sizeof(uint16)); + if (o==NULL) + { + TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); + return(0); } - return (TIFFWriteShortTable(tif, - TIFFTAG_TRANSFERFUNCTION, dir, ncols, tf)); + _TIFFmemcpy(&o[0],tif->tif_dir.td_transferfunction[0],m*sizeof(uint16)); + if (n>1) + _TIFFmemcpy(&o[m],tif->tif_dir.td_transferfunction[1],m*sizeof(uint16)); + if (n>2) + _TIFFmemcpy(&o[2*m],tif->tif_dir.td_transferfunction[2],m*sizeof(uint16)); + p=TIFFWriteDirectoryTagCheckedShortArray(tif,ndir,dir,TIFFTAG_TRANSFERFUNCTION,n*m,o); + _TIFFfree(o); + return(p); } static int -TIFFWriteInkNames(TIFF* tif, TIFFDirEntry* dir) +TIFFWriteDirectoryTagSubifd(TIFF* tif, uint32* ndir, TIFFDirEntry* dir) { - TIFFDirectory* td = &tif->tif_dir; + static const char module[] = "TIFFWriteDirectoryTagSubifd"; + uint64 m; + int n; + if (tif->tif_dir.td_nsubifd==0) + return(1); + if (dir==NULL) + { + (*ndir)++; + return(1); + } + m=tif->tif_dataoff; + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + uint32* o; + uint64* pa; + uint32* pb; + uint16 p; + o=_TIFFmalloc(tif->tif_dir.td_nsubifd*sizeof(uint32)); + if (o==NULL) + { + TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); + return(0); + } + pa=tif->tif_dir.td_subifd; + pb=o; + for (p=0; p < tif->tif_dir.td_nsubifd; p++) + { + assert(pa != 0); + assert(*pa <= 0xFFFFFFFFUL); + *pb++=(uint32)(*pa++); + } + n=TIFFWriteDirectoryTagCheckedIfdArray(tif,ndir,dir,TIFFTAG_SUBIFD,tif->tif_dir.td_nsubifd,o); + _TIFFfree(o); + } + else + n=TIFFWriteDirectoryTagCheckedIfd8Array(tif,ndir,dir,TIFFTAG_SUBIFD,tif->tif_dir.td_nsubifd,tif->tif_dir.td_subifd); + if (!n) + return(0); + /* + * Total hack: if this directory includes a SubIFD + * tag then force the next <n> directories to be + * written as ``sub directories'' of this one. This + * is used to write things like thumbnails and + * image masks that one wants to keep out of the + * normal directory linkage access mechanism. + */ + tif->tif_flags|=TIFF_INSUBIFD; + tif->tif_nsubifd=tif->tif_dir.td_nsubifd; + if (tif->tif_dir.td_nsubifd==1) + tif->tif_subifdoff=0; + else + tif->tif_subifdoff=m; + return(1); +} - dir->tdir_tag = TIFFTAG_INKNAMES; - dir->tdir_type = (short) TIFF_ASCII; - dir->tdir_count = td->td_inknameslen; - return (TIFFWriteByteArray(tif, dir, td->td_inknames)); +static int +TIFFWriteDirectoryTagCheckedAscii(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, char* value) +{ + assert(sizeof(char)==1); + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_ASCII,count,count,value)); } -/* - * Write a contiguous directory item. - */ static int -TIFFWriteData(TIFF* tif, TIFFDirEntry* dir, char* cp) +TIFFWriteDirectoryTagCheckedUndefinedArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value) { - tsize_t cc; + assert(sizeof(uint8)==1); + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_UNDEFINED,count,count,value)); +} - if (tif->tif_flags & TIFF_SWAB) { - switch (dir->tdir_type) { - case TIFF_SHORT: - case TIFF_SSHORT: - TIFFSwabArrayOfShort((uint16*) cp, dir->tdir_count); - break; - case TIFF_LONG: - case TIFF_SLONG: - case TIFF_FLOAT: - TIFFSwabArrayOfLong((uint32*) cp, dir->tdir_count); - break; - case TIFF_RATIONAL: - case TIFF_SRATIONAL: - TIFFSwabArrayOfLong((uint32*) cp, 2*dir->tdir_count); - break; - case TIFF_DOUBLE: - TIFFSwabArrayOfDouble((double*) cp, dir->tdir_count); - break; - } - } - dir->tdir_offset = tif->tif_dataoff; - cc = dir->tdir_count * TIFFDataWidth((TIFFDataType) dir->tdir_type); - if (SeekOK(tif, dir->tdir_offset) && - WriteOK(tif, cp, cc)) { - tif->tif_dataoff += (cc + 1) & ~1; - return (1); - } - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Error writing data for field \"%s\"", - _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name); - return (0); +#ifdef notdef +static int +TIFFWriteDirectoryTagCheckedByte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint8 value) +{ + assert(sizeof(uint8)==1); + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_BYTE,1,1,&value)); } +#endif -/* - * Similar to TIFFWriteDirectory(), but if the directory has already - * been written once, it is relocated to the end of the file, in case it - * has changed in size. Note that this will result in the loss of the - * previously used directory space. - */ +static int +TIFFWriteDirectoryTagCheckedByteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint8* value) +{ + assert(sizeof(uint8)==1); + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_BYTE,count,count,value)); +} -int -TIFFRewriteDirectory( TIFF *tif ) +#ifdef notdef +static int +TIFFWriteDirectoryTagCheckedSbyte(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int8 value) { - static const char module[] = "TIFFRewriteDirectory"; + assert(sizeof(int8)==1); + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SBYTE,1,1,&value)); +} +#endif - /* We don't need to do anything special if it hasn't been written. */ - if( tif->tif_diroff == 0 ) - return TIFFWriteDirectory( tif ); +static int +TIFFWriteDirectoryTagCheckedSbyteArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int8* value) +{ + assert(sizeof(int8)==1); + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SBYTE,count,count,value)); +} - /* - ** Find and zero the pointer to this directory, so that TIFFLinkDirectory - ** will cause it to be added after this directories current pre-link. - */ - - /* Is it the first directory in the file? */ - if (tif->tif_header.tiff_diroff == tif->tif_diroff) - { - tif->tif_header.tiff_diroff = 0; - tif->tif_diroff = 0; +static int +TIFFWriteDirectoryTagCheckedShort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 value) +{ + uint16 m; + assert(sizeof(uint16)==2); + m=value; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort(&m); + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SHORT,1,2,&m)); +} - TIFFSeekFile(tif, (toff_t)(TIFF_MAGIC_SIZE+TIFF_VERSION_SIZE), - SEEK_SET); - if (!WriteOK(tif, &(tif->tif_header.tiff_diroff), - sizeof (tif->tif_diroff))) - { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Error updating TIFF header"); - return (0); - } - } - else - { - toff_t nextdir, off; +static int +TIFFWriteDirectoryTagCheckedShortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint16* value) +{ + assert(count<0x80000000); + assert(sizeof(uint16)==2); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfShort(value,count); + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SHORT,count,count*2,value)); +} - nextdir = tif->tif_header.tiff_diroff; - do { - uint16 dircount; +#ifdef notdef +static int +TIFFWriteDirectoryTagCheckedSshort(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int16 value) +{ + int16 m; + assert(sizeof(int16)==2); + m=value; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort((uint16*)(&m)); + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SSHORT,1,2,&m)); +} +#endif - if (!SeekOK(tif, nextdir) || - !ReadOK(tif, &dircount, sizeof (dircount))) { - TIFFErrorExt(tif->tif_clientdata, module, - "Error fetching directory count"); - return (0); +static int +TIFFWriteDirectoryTagCheckedSshortArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int16* value) +{ + assert(count<0x80000000); + assert(sizeof(int16)==2); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfShort((uint16*)value,count); + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SSHORT,count,count*2,value)); +} + +static int +TIFFWriteDirectoryTagCheckedLong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 value) +{ + uint32 m; + assert(sizeof(uint32)==4); + m=value; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(&m); + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_LONG,1,4,&m)); +} + +static int +TIFFWriteDirectoryTagCheckedLongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value) +{ + assert(count<0x40000000); + assert(sizeof(uint32)==4); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfLong(value,count); + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_LONG,count,count*4,value)); +} + +#ifdef notdef +static int +TIFFWriteDirectoryTagCheckedSlong(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int32 value) +{ + int32 m; + assert(sizeof(int32)==4); + m=value; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong((uint32*)(&m)); + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SLONG,1,4,&m)); +} +#endif + +static int +TIFFWriteDirectoryTagCheckedSlongArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int32* value) +{ + assert(count<0x40000000); + assert(sizeof(int32)==4); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfLong((uint32*)value,count); + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SLONG,count,count*4,value)); +} + +#ifdef notdef +static int +TIFFWriteDirectoryTagCheckedLong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint64 value) +{ + uint64 m; + assert(sizeof(uint64)==8); + assert(tif->tif_flags&TIFF_BIGTIFF); + m=value; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8(&m); + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_LONG8,1,8,&m)); +} +#endif + +static int +TIFFWriteDirectoryTagCheckedLong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value) +{ + assert(count<0x20000000); + assert(sizeof(uint64)==8); + assert(tif->tif_flags&TIFF_BIGTIFF); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfLong8(value,count); + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_LONG8,count,count*8,value)); +} + +#ifdef notdef +static int +TIFFWriteDirectoryTagCheckedSlong8(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, int64 value) +{ + int64 m; + assert(sizeof(int64)==8); + assert(tif->tif_flags&TIFF_BIGTIFF); + m=value; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8((uint64*)(&m)); + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SLONG8,1,8,&m)); +} +#endif + +static int +TIFFWriteDirectoryTagCheckedSlong8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, int64* value) +{ + assert(count<0x20000000); + assert(sizeof(int64)==8); + assert(tif->tif_flags&TIFF_BIGTIFF); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfLong8((uint64*)value,count); + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SLONG8,count,count*8,value)); +} + +static int +TIFFWriteDirectoryTagCheckedRational(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value) +{ + uint32 m[2]; + assert(value>=0.0); + assert(sizeof(uint32)==4); + if (value<=0.0) + { + m[0]=0; + m[1]=1; + } + else if (value==(double)(uint32)value) + { + m[0]=(uint32)value; + m[1]=1; + } + else if (value<1.0) + { + m[0]=(uint32)(value*0xFFFFFFFF); + m[1]=0xFFFFFFFF; + } + else + { + m[0]=0xFFFFFFFF; + m[1]=(uint32)(0xFFFFFFFF/value); + } + if (tif->tif_flags&TIFF_SWAB) + { + TIFFSwabLong(&m[0]); + TIFFSwabLong(&m[1]); + } + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_RATIONAL,1,8,&m[0])); +} + +static int +TIFFWriteDirectoryTagCheckedRationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value) +{ + static const char module[] = "TIFFWriteDirectoryTagCheckedRationalArray"; + uint32* m; + float* na; + uint32* nb; + uint32 nc; + int o; + assert(sizeof(uint32)==4); + m=_TIFFmalloc(count*2*sizeof(uint32)); + if (m==NULL) + { + TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); + return(0); + } + for (na=value, nb=m, nc=0; nc<count; na++, nb+=2, nc++) + { + if (*na<=0.0) + { + nb[0]=0; + nb[1]=1; } - if (tif->tif_flags & TIFF_SWAB) - TIFFSwabShort(&dircount); - (void) TIFFSeekFile(tif, - dircount * sizeof (TIFFDirEntry), SEEK_CUR); - if (!ReadOK(tif, &nextdir, sizeof (nextdir))) { - TIFFErrorExt(tif->tif_clientdata, module, - "Error fetching directory link"); - return (0); + else if (*na==(float)(uint32)(*na)) + { + nb[0]=(uint32)(*na); + nb[1]=1; + } + else if (*na<1.0) + { + nb[0]=(uint32)((*na)*0xFFFFFFFF); + nb[1]=0xFFFFFFFF; + } + else + { + nb[0]=0xFFFFFFFF; + nb[1]=(uint32)(0xFFFFFFFF/(*na)); } - if (tif->tif_flags & TIFF_SWAB) - TIFFSwabLong(&nextdir); - } while (nextdir != tif->tif_diroff && nextdir != 0); - off = TIFFSeekFile(tif, 0, SEEK_CUR); /* get current offset */ - (void) TIFFSeekFile(tif, off - (toff_t)sizeof(nextdir), SEEK_SET); - tif->tif_diroff = 0; - if (!WriteOK(tif, &(tif->tif_diroff), sizeof (nextdir))) { - TIFFErrorExt(tif->tif_clientdata, module, - "Error writing directory link"); - return (0); } - } + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfLong(m,count*2); + o=TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_RATIONAL,count,count*8,&m[0]); + _TIFFfree(m); + return(o); +} - /* - ** Now use TIFFWriteDirectory() normally. - */ +static int +TIFFWriteDirectoryTagCheckedSrationalArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value) +{ + static const char module[] = "TIFFWriteDirectoryTagCheckedSrationalArray"; + int32* m; + float* na; + int32* nb; + uint32 nc; + int o; + assert(sizeof(int32)==4); + m=_TIFFmalloc(count*2*sizeof(int32)); + if (m==NULL) + { + TIFFErrorExt(tif->tif_clientdata,module,"Out of memory"); + return(0); + } + for (na=value, nb=m, nc=0; nc<count; na++, nb+=2, nc++) + { + if (*na<0.0) + { + if (*na==(int32)(*na)) + { + nb[0]=(int32)(*na); + nb[1]=1; + } + else if (*na>-1.0) + { + nb[0]=-(int32)((-*na)*0x7FFFFFFF); + nb[1]=0x7FFFFFFF; + } + else + { + nb[0]=-0x7FFFFFFF; + nb[1]=(int32)(0x7FFFFFFF/(-*na)); + } + } + else + { + if (*na==(int32)(*na)) + { + nb[0]=(int32)(*na); + nb[1]=1; + } + else if (*na<1.0) + { + nb[0]=(int32)((*na)*0x7FFFFFFF); + nb[1]=0x7FFFFFFF; + } + else + { + nb[0]=0x7FFFFFFF; + nb[1]=(int32)(0x7FFFFFFF/(*na)); + } + } + } + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfLong((uint32*)m,count*2); + o=TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_SRATIONAL,count,count*8,&m[0]); + _TIFFfree(m); + return(o); +} - return TIFFWriteDirectory( tif ); +#ifdef notdef +static int +TIFFWriteDirectoryTagCheckedFloat(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, float value) +{ + float m; + assert(sizeof(float)==4); + m=value; + TIFFCvtNativeToIEEEFloat(tif,1,&m); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabFloat(&m); + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_FLOAT,1,4,&m)); } +#endif +static int +TIFFWriteDirectoryTagCheckedFloatArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, float* value) +{ + assert(count<0x40000000); + assert(sizeof(float)==4); + TIFFCvtNativeToIEEEFloat(tif,count,&value); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfFloat(value,count); + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_FLOAT,count,count*4,value)); +} + +#ifdef notdef +static int +TIFFWriteDirectoryTagCheckedDouble(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, double value) +{ + double m; + assert(sizeof(double)==8); + m=value; + TIFFCvtNativeToIEEEDouble(tif,1,&m); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabDouble(&m); + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_DOUBLE,1,8,&m)); +} +#endif + +static int +TIFFWriteDirectoryTagCheckedDoubleArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, double* value) +{ + assert(count<0x20000000); + assert(sizeof(double)==8); + TIFFCvtNativeToIEEEDouble(tif,count,&value); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfDouble(value,count); + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_DOUBLE,count,count*8,value)); +} + +static int +TIFFWriteDirectoryTagCheckedIfdArray(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint32* value) +{ + assert(count<0x40000000); + assert(sizeof(uint32)==4); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfLong(value,count); + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_IFD,count,count*4,value)); +} + +static int +TIFFWriteDirectoryTagCheckedIfd8Array(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint32 count, uint64* value) +{ + assert(count<0x20000000); + assert(sizeof(uint64)==8); + assert(tif->tif_flags&TIFF_BIGTIFF); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabArrayOfLong8(value,count); + return(TIFFWriteDirectoryTagData(tif,ndir,dir,tag,TIFF_IFD8,count,count*8,value)); +} + +static int +TIFFWriteDirectoryTagData(TIFF* tif, uint32* ndir, TIFFDirEntry* dir, uint16 tag, uint16 datatype, uint32 count, uint32 datalength, void* data) +{ + static const char module[] = "TIFFWriteDirectoryTagData"; + uint32 m; + m=0; + while (m<(*ndir)) + { + assert(dir[m].tdir_tag!=tag); + if (dir[m].tdir_tag>tag) + break; + m++; + } + if (m<(*ndir)) + { + uint32 n; + for (n=*ndir; n>m; n--) + dir[n]=dir[n-1]; + } + dir[m].tdir_tag=tag; + dir[m].tdir_type=datatype; + dir[m].tdir_count=count; + dir[m].tdir_offset.toff_long8 = 0; + if (datalength<=((tif->tif_flags&TIFF_BIGTIFF)?0x8U:0x4U)) + _TIFFmemcpy(&dir[m].tdir_offset,data,datalength); + else + { + uint64 na,nb; + na=tif->tif_dataoff; + nb=na+datalength; + if (!(tif->tif_flags&TIFF_BIGTIFF)) + nb=(uint32)nb; + if ((nb<na)||(nb<datalength)) + { + TIFFErrorExt(tif->tif_clientdata,module,"Maximum TIFF file size exceeded"); + return(0); + } + if (!SeekOK(tif,na)) + { + TIFFErrorExt(tif->tif_clientdata,module,"IO error writing tag data"); + return(0); + } + assert(datalength<0x80000000UL); + if (!WriteOK(tif,data,(tmsize_t)datalength)) + { + TIFFErrorExt(tif->tif_clientdata,module,"IO error writing tag data"); + return(0); + } + tif->tif_dataoff=nb; + if (tif->tif_dataoff&1) + tif->tif_dataoff++; + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + uint32 o; + o=(uint32)na; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong(&o); + _TIFFmemcpy(&dir[m].tdir_offset,&o,4); + } + else + { + dir[m].tdir_offset.toff_long8 = na; + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8(&dir[m].tdir_offset.toff_long8); + } + } + (*ndir)++; + return(1); +} /* * Link the current directory into the directory chain for the file. @@ -1323,85 +2367,544 @@ static int TIFFLinkDirectory(TIFF* tif) { static const char module[] = "TIFFLinkDirectory"; - toff_t nextdir; - toff_t diroff, off; - tif->tif_diroff = (TIFFSeekFile(tif, (toff_t) 0, SEEK_END)+1) &~ 1; - diroff = tif->tif_diroff; - if (tif->tif_flags & TIFF_SWAB) - TIFFSwabLong(&diroff); + tif->tif_diroff = (TIFFSeekFile(tif,0,SEEK_END)+1) &~ 1; /* * Handle SubIFDs */ - if (tif->tif_flags & TIFF_INSUBIFD) { - (void) TIFFSeekFile(tif, tif->tif_subifdoff, SEEK_SET); - if (!WriteOK(tif, &diroff, sizeof (diroff))) { - TIFFErrorExt(tif->tif_clientdata, module, - "%s: Error writing SubIFD directory link", - tif->tif_name); - return (0); + if (tif->tif_flags & TIFF_INSUBIFD) + { + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + uint32 m; + m = (uint32)tif->tif_diroff; + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabLong(&m); + (void) TIFFSeekFile(tif, tif->tif_subifdoff, SEEK_SET); + if (!WriteOK(tif, &m, 4)) { + TIFFErrorExt(tif->tif_clientdata, module, + "Error writing SubIFD directory link"); + return (0); + } + /* + * Advance to the next SubIFD or, if this is + * the last one configured, revert back to the + * normal directory linkage. + */ + if (--tif->tif_nsubifd) + tif->tif_subifdoff += 4; + else + tif->tif_flags &= ~TIFF_INSUBIFD; + return (1); } - /* - * Advance to the next SubIFD or, if this is - * the last one configured, revert back to the - * normal directory linkage. - */ - if (--tif->tif_nsubifd) - tif->tif_subifdoff += sizeof (diroff); else - tif->tif_flags &= ~TIFF_INSUBIFD; - return (1); + { + uint64 m; + m = tif->tif_diroff; + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabLong8(&m); + (void) TIFFSeekFile(tif, tif->tif_subifdoff, SEEK_SET); + if (!WriteOK(tif, &m, 8)) { + TIFFErrorExt(tif->tif_clientdata, module, + "Error writing SubIFD directory link"); + return (0); + } + /* + * Advance to the next SubIFD or, if this is + * the last one configured, revert back to the + * normal directory linkage. + */ + if (--tif->tif_nsubifd) + tif->tif_subifdoff += 8; + else + tif->tif_flags &= ~TIFF_INSUBIFD; + return (1); + } } - if (tif->tif_header.tiff_diroff == 0) { + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + uint32 m; + uint32 nextdir; + m = (uint32)(tif->tif_diroff); + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabLong(&m); + if (tif->tif_header.classic.tiff_diroff == 0) { + /* + * First directory, overwrite offset in header. + */ + tif->tif_header.classic.tiff_diroff = (uint32) tif->tif_diroff; + (void) TIFFSeekFile(tif,4, SEEK_SET); + if (!WriteOK(tif, &m, 4)) { + TIFFErrorExt(tif->tif_clientdata, tif->tif_name, + "Error writing TIFF header"); + return (0); + } + return (1); + } /* - * First directory, overwrite offset in header. + * Not the first directory, search to the last and append. */ - tif->tif_header.tiff_diroff = tif->tif_diroff; - (void) TIFFSeekFile(tif, - (toff_t)(TIFF_MAGIC_SIZE+TIFF_VERSION_SIZE), - SEEK_SET); - if (!WriteOK(tif, &diroff, sizeof (diroff))) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Error writing TIFF header"); - return (0); + nextdir = tif->tif_header.classic.tiff_diroff; + while(1) { + uint16 dircount; + uint32 nextnextdir; + + if (!SeekOK(tif, nextdir) || + !ReadOK(tif, &dircount, 2)) { + TIFFErrorExt(tif->tif_clientdata, module, + "Error fetching directory count"); + return (0); + } + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabShort(&dircount); + (void) TIFFSeekFile(tif, + nextdir+2+dircount*12, SEEK_SET); + if (!ReadOK(tif, &nextnextdir, 4)) { + TIFFErrorExt(tif->tif_clientdata, module, + "Error fetching directory link"); + return (0); + } + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabLong(&nextnextdir); + if (nextnextdir==0) + { + (void) TIFFSeekFile(tif, + nextdir+2+dircount*12, SEEK_SET); + if (!WriteOK(tif, &m, 4)) { + TIFFErrorExt(tif->tif_clientdata, module, + "Error writing directory link"); + return (0); + } + break; + } + nextdir=nextnextdir; } - return (1); } - /* - * Not the first directory, search to the last and append. - */ - nextdir = tif->tif_header.tiff_diroff; - do { - uint16 dircount; - - if (!SeekOK(tif, nextdir) || - !ReadOK(tif, &dircount, sizeof (dircount))) { - TIFFErrorExt(tif->tif_clientdata, module, - "Error fetching directory count"); - return (0); - } + else + { + uint64 m; + uint64 nextdir; + m = tif->tif_diroff; if (tif->tif_flags & TIFF_SWAB) - TIFFSwabShort(&dircount); - (void) TIFFSeekFile(tif, - dircount * sizeof (TIFFDirEntry), SEEK_CUR); - if (!ReadOK(tif, &nextdir, sizeof (nextdir))) { - TIFFErrorExt(tif->tif_clientdata, module, - "Error fetching directory link"); - return (0); + TIFFSwabLong8(&m); + if (tif->tif_header.big.tiff_diroff == 0) { + /* + * First directory, overwrite offset in header. + */ + tif->tif_header.big.tiff_diroff = tif->tif_diroff; + (void) TIFFSeekFile(tif,8, SEEK_SET); + if (!WriteOK(tif, &m, 8)) { + TIFFErrorExt(tif->tif_clientdata, tif->tif_name, + "Error writing TIFF header"); + return (0); + } + return (1); + } + /* + * Not the first directory, search to the last and append. + */ + nextdir = tif->tif_header.big.tiff_diroff; + while(1) { + uint64 dircount64; + uint16 dircount; + uint64 nextnextdir; + + if (!SeekOK(tif, nextdir) || + !ReadOK(tif, &dircount64, 8)) { + TIFFErrorExt(tif->tif_clientdata, module, + "Error fetching directory count"); + return (0); + } + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabLong8(&dircount64); + if (dircount64>0xFFFF) + { + TIFFErrorExt(tif->tif_clientdata, module, + "Sanity check on tag count failed, likely corrupt TIFF"); + return (0); + } + dircount=(uint16)dircount64; + (void) TIFFSeekFile(tif, + nextdir+8+dircount*20, SEEK_SET); + if (!ReadOK(tif, &nextnextdir, 8)) { + TIFFErrorExt(tif->tif_clientdata, module, + "Error fetching directory link"); + return (0); + } + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabLong8(&nextnextdir); + if (nextnextdir==0) + { + (void) TIFFSeekFile(tif, + nextdir+8+dircount*20, SEEK_SET); + if (!WriteOK(tif, &m, 8)) { + TIFFErrorExt(tif->tif_clientdata, module, + "Error writing directory link"); + return (0); + } + break; + } + nextdir=nextnextdir; } - if (tif->tif_flags & TIFF_SWAB) - TIFFSwabLong(&nextdir); - } while (nextdir != 0); - off = TIFFSeekFile(tif, 0, SEEK_CUR); /* get current offset */ - (void) TIFFSeekFile(tif, off - (toff_t)sizeof(nextdir), SEEK_SET); - if (!WriteOK(tif, &diroff, sizeof (diroff))) { - TIFFErrorExt(tif->tif_clientdata, module, - "Error writing directory link"); - return (0); } return (1); } +/************************************************************************/ +/* TIFFRewriteField() */ +/* */ +/* Rewrite a field in the directory on disk without regard to */ +/* updating the TIFF directory structure in memory. Currently */ +/* only supported for field that already exist in the on-disk */ +/* directory. Mainly used for updating stripoffset / */ +/* stripbytecount values after the directory is already on */ +/* disk. */ +/* */ +/* Returns zero on failure, and one on success. */ +/************************************************************************/ + +int +_TIFFRewriteField(TIFF* tif, uint16 tag, TIFFDataType in_datatype, + tmsize_t count, void* data) +{ + static const char module[] = "TIFFResetField"; + /* const TIFFField* fip = NULL; */ + uint16 dircount; + tmsize_t dirsize; + uint8 direntry_raw[20]; + uint16 entry_tag = 0; + uint16 entry_type = 0; + uint64 entry_count = 0; + uint64 entry_offset = 0; + int value_in_entry = 0; + uint64 read_offset; + uint8 *buf_to_write = NULL; + TIFFDataType datatype; + +/* -------------------------------------------------------------------- */ +/* Find field definition. */ +/* -------------------------------------------------------------------- */ + /*fip =*/ TIFFFindField(tif, tag, TIFF_ANY); + +/* -------------------------------------------------------------------- */ +/* Do some checking this is a straight forward case. */ +/* -------------------------------------------------------------------- */ + if( isMapped(tif) ) + { + TIFFErrorExt( tif->tif_clientdata, module, + "Memory mapped files not currently supported for this operation." ); + return 0; + } + + if( tif->tif_diroff == 0 ) + { + TIFFErrorExt( tif->tif_clientdata, module, + "Attempt to reset field on directory not already on disk." ); + return 0; + } + +/* -------------------------------------------------------------------- */ +/* Read the directory entry count. */ +/* -------------------------------------------------------------------- */ + if (!SeekOK(tif, tif->tif_diroff)) { + TIFFErrorExt(tif->tif_clientdata, module, + "%s: Seek error accessing TIFF directory", + tif->tif_name); + return 0; + } + + read_offset = tif->tif_diroff; + + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + if (!ReadOK(tif, &dircount, sizeof (uint16))) { + TIFFErrorExt(tif->tif_clientdata, module, + "%s: Can not read TIFF directory count", + tif->tif_name); + return 0; + } + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabShort(&dircount); + dirsize = 12; + read_offset += 2; + } else { + uint64 dircount64; + if (!ReadOK(tif, &dircount64, sizeof (uint64))) { + TIFFErrorExt(tif->tif_clientdata, module, + "%s: Can not read TIFF directory count", + tif->tif_name); + return 0; + } + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabLong8(&dircount64); + dircount = (uint16)dircount64; + dirsize = 20; + read_offset += 8; + } + +/* -------------------------------------------------------------------- */ +/* Read through directory to find target tag. */ +/* -------------------------------------------------------------------- */ + while( dircount > 0 ) + { + if (!ReadOK(tif, direntry_raw, dirsize)) { + TIFFErrorExt(tif->tif_clientdata, module, + "%s: Can not read TIFF directory entry.", + tif->tif_name); + return 0; + } + + memcpy( &entry_tag, direntry_raw + 0, sizeof(uint16) ); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort( &entry_tag ); + + if( entry_tag == tag ) + break; + + read_offset += dirsize; + } + + if( entry_tag != tag ) + { + TIFFErrorExt(tif->tif_clientdata, module, + "%s: Could not find tag %d.", + tif->tif_name, tag ); + return 0; + } + +/* -------------------------------------------------------------------- */ +/* Extract the type, count and offset for this entry. */ +/* -------------------------------------------------------------------- */ + memcpy( &entry_type, direntry_raw + 2, sizeof(uint16) ); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort( &entry_type ); + + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + uint32 value; + + memcpy( &value, direntry_raw + 4, sizeof(uint32) ); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong( &value ); + entry_count = value; + + memcpy( &value, direntry_raw + 8, sizeof(uint32) ); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong( &value ); + entry_offset = value; + } + else + { + memcpy( &entry_count, direntry_raw + 4, sizeof(uint64) ); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8( &entry_count ); + + memcpy( &entry_offset, direntry_raw + 12, sizeof(uint64) ); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8( &entry_offset ); + } + +/* -------------------------------------------------------------------- */ +/* What data type do we want to write this as? */ +/* -------------------------------------------------------------------- */ + if( TIFFDataWidth(in_datatype) == 8 && !(tif->tif_flags&TIFF_BIGTIFF) ) + { + if( in_datatype == TIFF_LONG8 ) + datatype = TIFF_LONG; + else if( in_datatype == TIFF_SLONG8 ) + datatype = TIFF_SLONG; + else if( in_datatype == TIFF_IFD8 ) + datatype = TIFF_IFD; + else + datatype = in_datatype; + } + else + datatype = in_datatype; + +/* -------------------------------------------------------------------- */ +/* Prepare buffer of actual data to write. This includes */ +/* swabbing as needed. */ +/* -------------------------------------------------------------------- */ + buf_to_write = + (uint8 *)_TIFFCheckMalloc(tif, count, TIFFDataWidth(datatype), + "for field buffer."); + if (!buf_to_write) + return 0; + + if( datatype == in_datatype ) + memcpy( buf_to_write, data, count * TIFFDataWidth(datatype) ); + else if( datatype == TIFF_SLONG && in_datatype == TIFF_SLONG8 ) + { + tmsize_t i; + + for( i = 0; i < count; i++ ) + { + ((int32 *) buf_to_write)[i] = + (int32) ((int64 *) data)[i]; + if( (int64) ((int32 *) buf_to_write)[i] != ((int64 *) data)[i] ) + { + _TIFFfree( buf_to_write ); + TIFFErrorExt( tif->tif_clientdata, module, + "Value exceeds 32bit range of output type." ); + return 0; + } + } + } + else if( (datatype == TIFF_LONG && in_datatype == TIFF_LONG8) + || (datatype == TIFF_IFD && in_datatype == TIFF_IFD8) ) + { + tmsize_t i; + + for( i = 0; i < count; i++ ) + { + ((uint32 *) buf_to_write)[i] = + (uint32) ((uint64 *) data)[i]; + if( (uint64) ((uint32 *) buf_to_write)[i] != ((uint64 *) data)[i] ) + { + _TIFFfree( buf_to_write ); + TIFFErrorExt( tif->tif_clientdata, module, + "Value exceeds 32bit range of output type." ); + return 0; + } + } + } + + if( TIFFDataWidth(datatype) > 1 && (tif->tif_flags&TIFF_SWAB) ) + { + if( TIFFDataWidth(datatype) == 2 ) + TIFFSwabArrayOfShort( (uint16 *) buf_to_write, count ); + else if( TIFFDataWidth(datatype) == 4 ) + TIFFSwabArrayOfLong( (uint32 *) buf_to_write, count ); + else if( TIFFDataWidth(datatype) == 8 ) + TIFFSwabArrayOfLong8( (uint64 *) buf_to_write, count ); + } + +/* -------------------------------------------------------------------- */ +/* Is this a value that fits into the directory entry? */ +/* -------------------------------------------------------------------- */ + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + if( TIFFDataWidth(datatype) * count <= 4 ) + { + entry_offset = read_offset + 8; + value_in_entry = 1; + } + } + else + { + if( TIFFDataWidth(datatype) * count <= 8 ) + { + entry_offset = read_offset + 12; + value_in_entry = 1; + } + } + +/* -------------------------------------------------------------------- */ +/* If the tag type, and count match, then we just write it out */ +/* over the old values without altering the directory entry at */ +/* all. */ +/* -------------------------------------------------------------------- */ + if( entry_count == (uint64)count && entry_type == (uint16) datatype ) + { + if (!SeekOK(tif, entry_offset)) { + _TIFFfree( buf_to_write ); + TIFFErrorExt(tif->tif_clientdata, module, + "%s: Seek error accessing TIFF directory", + tif->tif_name); + return 0; + } + if (!WriteOK(tif, buf_to_write, count*TIFFDataWidth(datatype))) { + _TIFFfree( buf_to_write ); + TIFFErrorExt(tif->tif_clientdata, module, + "Error writing directory link"); + return (0); + } + + _TIFFfree( buf_to_write ); + return 1; + } + +/* -------------------------------------------------------------------- */ +/* Otherwise, we write the new tag data at the end of the file. */ +/* -------------------------------------------------------------------- */ + if( !value_in_entry ) + { + entry_offset = TIFFSeekFile(tif,0,SEEK_END); + + if (!WriteOK(tif, buf_to_write, count*TIFFDataWidth(datatype))) { + _TIFFfree( buf_to_write ); + TIFFErrorExt(tif->tif_clientdata, module, + "Error writing directory link"); + return (0); + } + + _TIFFfree( buf_to_write ); + } + else + { + memcpy( &entry_offset, buf_to_write, count*TIFFDataWidth(datatype)); + } + +/* -------------------------------------------------------------------- */ +/* Adjust the directory entry. */ +/* -------------------------------------------------------------------- */ + entry_type = datatype; + memcpy( direntry_raw + 2, &entry_type, sizeof(uint16) ); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabShort( (uint16 *) (direntry_raw + 2) ); + + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + uint32 value; + + value = (uint32) entry_count; + memcpy( direntry_raw + 4, &value, sizeof(uint32) ); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong( (uint32 *) (direntry_raw + 4) ); + + value = (uint32) entry_offset; + memcpy( direntry_raw + 8, &value, sizeof(uint32) ); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong( (uint32 *) (direntry_raw + 8) ); + } + else + { + memcpy( direntry_raw + 4, &entry_count, sizeof(uint64) ); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8( (uint64 *) (direntry_raw + 4) ); + + memcpy( direntry_raw + 12, &entry_offset, sizeof(uint64) ); + if (tif->tif_flags&TIFF_SWAB) + TIFFSwabLong8( (uint64 *) (direntry_raw + 12) ); + } + +/* -------------------------------------------------------------------- */ +/* Write the directory entry out to disk. */ +/* -------------------------------------------------------------------- */ + if (!SeekOK(tif, read_offset )) { + TIFFErrorExt(tif->tif_clientdata, module, + "%s: Seek error accessing TIFF directory", + tif->tif_name); + return 0; + } + + if (!WriteOK(tif, direntry_raw,dirsize)) + { + TIFFErrorExt(tif->tif_clientdata, module, + "%s: Can not write TIFF directory entry.", + tif->tif_name); + return 0; + } + + return 1; +} /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_dumpmode.c b/src/3rdparty/libtiff/libtiff/tif_dumpmode.c index 767d6d9..a94cf0b 100644 --- a/src/3rdparty/libtiff/libtiff/tif_dumpmode.c +++ b/src/3rdparty/libtiff/libtiff/tif_dumpmode.c @@ -1,4 +1,4 @@ -/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_dumpmode.c,v 1.5.2.1 2009-01-01 00:10:43 bfriesen Exp $ */ +/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_dumpmode.c,v 1.14 2011-04-02 20:54:09 bfriesen Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler @@ -31,22 +31,29 @@ */ #include "tiffiop.h" +static int +DumpFixupTags(TIFF* tif) +{ + (void) tif; + return (1); +} + /* * Encode a hunk of pixels. */ static int -DumpModeEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s) +DumpModeEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s) { (void) s; while (cc > 0) { - tsize_t n; + tmsize_t n; n = cc; if (tif->tif_rawcc + n > tif->tif_rawdatasize) n = tif->tif_rawdatasize - tif->tif_rawcc; assert( n > 0 ); - + /* * Avoid copy if client has setup raw * data buffer to avoid extra copy. @@ -68,15 +75,24 @@ DumpModeEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s) * Decode a hunk of pixels. */ static int -DumpModeDecode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) +DumpModeDecode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s) { + static const char module[] = "DumpModeDecode"; (void) s; -/* fprintf(stderr,"DumpModeDecode: scanline %ld, expected %ld bytes, got %ld bytes\n", */ -/* (long) tif->tif_row, (long) tif->tif_rawcc, (long) cc); */ if (tif->tif_rawcc < cc) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "DumpModeDecode: Not enough data for scanline %d", - tif->tif_row); +#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) + TIFFErrorExt(tif->tif_clientdata, module, +"Not enough data for scanline %lu, expected a request for at most %I64d bytes, got a request for %I64d bytes", + (unsigned long) tif->tif_row, + (signed __int64) tif->tif_rawcc, + (signed __int64) cc); +#else + TIFFErrorExt(tif->tif_clientdata, module, +"Not enough data for scanline %lu, expected a request for at most %lld bytes, got a request for %lld bytes", + (unsigned long) tif->tif_row, + (signed long long) tif->tif_rawcc, + (signed long long) cc); +#endif return (0); } /* @@ -86,7 +102,7 @@ DumpModeDecode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) if (tif->tif_rawcp != buf) _TIFFmemcpy(buf, tif->tif_rawcp, cc); tif->tif_rawcp += cc; - tif->tif_rawcc -= cc; + tif->tif_rawcc -= cc; return (1); } @@ -108,12 +124,20 @@ int TIFFInitDumpMode(TIFF* tif, int scheme) { (void) scheme; + tif->tif_fixuptags = DumpFixupTags; tif->tif_decoderow = DumpModeDecode; tif->tif_decodestrip = DumpModeDecode; tif->tif_decodetile = DumpModeDecode; tif->tif_encoderow = DumpModeEncode; tif->tif_encodestrip = DumpModeEncode; - tif->tif_encodetile = DumpModeEncode; + tif->tif_encodetile = DumpModeEncode; tif->tif_seek = DumpModeSeek; return (1); } +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_error.c b/src/3rdparty/libtiff/libtiff/tif_error.c index 7025080..0bc8b87 100644 --- a/src/3rdparty/libtiff/libtiff/tif_error.c +++ b/src/3rdparty/libtiff/libtiff/tif_error.c @@ -1,4 +1,4 @@ -/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_error.c,v 1.4 2005/12/23 01:18:59 joris Exp $ */ +/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_error.c,v 1.5 2010-03-10 18:56:48 bfriesen Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler @@ -71,3 +71,10 @@ TIFFErrorExt(thandle_t fd, const char* module, const char* fmt, ...) va_end(ap); } +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_extension.c b/src/3rdparty/libtiff/libtiff/tif_extension.c index 6861522..10afd41 100644 --- a/src/3rdparty/libtiff/libtiff/tif_extension.c +++ b/src/3rdparty/libtiff/libtiff/tif_extension.c @@ -1,4 +1,4 @@ -/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_extension.c,v 1.4 2004/10/02 13:29:41 dron Exp $ */ +/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_extension.c,v 1.7 2010-03-10 18:56:48 bfriesen Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler @@ -41,13 +41,13 @@ int TIFFGetTagListCount( TIFF *tif ) return td->td_customValueCount; } -ttag_t TIFFGetTagListEntry( TIFF *tif, int tag_index ) +uint32 TIFFGetTagListEntry( TIFF *tif, int tag_index ) { TIFFDirectory* td = &tif->tif_dir; if( tag_index < 0 || tag_index >= td->td_customValueCount ) - return (ttag_t) -1; + return (uint32)(-1); else return td->td_customValues[tag_index].info->field_tag; } @@ -102,10 +102,17 @@ void TIFFSetClientInfo( TIFF *tif, void *data, const char *name ) link = (TIFFClientInfoLink *) _TIFFmalloc(sizeof(TIFFClientInfoLink)); assert (link != NULL); link->next = tif->tif_clientinfo; - link->name = (char *) _TIFFmalloc(strlen(name)+1); + link->name = (char *) _TIFFmalloc((tmsize_t)(strlen(name)+1)); assert (link->name != NULL); strcpy(link->name, name); link->data = data; tif->tif_clientinfo = link; } +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_fax3.c b/src/3rdparty/libtiff/libtiff/tif_fax3.c index b560d56..2b2dccd 100644 --- a/src/3rdparty/libtiff/libtiff/tif_fax3.c +++ b/src/3rdparty/libtiff/libtiff/tif_fax3.c @@ -1,4 +1,4 @@ -/* $Id: tif_fax3.c,v 1.43.2.5 2009-01-01 00:10:43 bfriesen Exp $ */ +/* $Id: tif_fax3.c,v 1.74 2012-06-21 02:01:31 fwarmerdam Exp $ */ /* * Copyright (c) 1990-1997 Sam Leffler @@ -48,22 +48,19 @@ * derived from this ``base state'' block. */ typedef struct { - int rw_mode; /* O_RDONLY for decode, else encode */ - int mode; /* operating mode */ - uint32 rowbytes; /* bytes in a decoded scanline */ - uint32 rowpixels; /* pixels in a scanline */ - - uint16 cleanfaxdata; /* CleanFaxData tag */ - uint32 badfaxrun; /* BadFaxRun tag */ - uint32 badfaxlines; /* BadFaxLines tag */ - uint32 groupoptions; /* Group 3/4 options tag */ - uint32 recvparams; /* encoded Class 2 session params */ - char* subaddress; /* subaddress string */ - uint32 recvtime; /* time spent receiving (secs) */ - char* faxdcs; /* Table 2/T.30 encoded session params */ - TIFFVGetMethod vgetparent; /* super-class method */ - TIFFVSetMethod vsetparent; /* super-class method */ - TIFFPrintMethod printdir; /* super-class method */ + int rw_mode; /* O_RDONLY for decode, else encode */ + int mode; /* operating mode */ + tmsize_t rowbytes; /* bytes in a decoded scanline */ + uint32 rowpixels; /* pixels in a scanline */ + + uint16 cleanfaxdata; /* CleanFaxData tag */ + uint32 badfaxrun; /* BadFaxRun tag */ + uint32 badfaxlines; /* BadFaxLines tag */ + uint32 groupoptions; /* Group 3/4 options tag */ + + TIFFVGetMethod vgetparent; /* super-class method */ + TIFFVSetMethod vsetparent; /* super-class method */ + TIFFPrintMethod printdir; /* super-class method */ } Fax3BaseState; #define Fax3State(tif) ((Fax3BaseState*) (tif)->tif_data) @@ -89,12 +86,11 @@ typedef struct { int line; } Fax3CodecState; -#define DecoderState(tif) ((Fax3CodecState*) Fax3State(tif)) -#define EncoderState(tif) ((Fax3CodecState*) Fax3State(tif)) +#define DecoderState(tif) ((Fax3CodecState*) Fax3State(tif)) +#define EncoderState(tif) ((Fax3CodecState*) Fax3State(tif)) -#define is2DEncoding(sp) \ - (sp->b.groupoptions & GROUP3OPT_2DENCODING) -#define isAligned(p,t) ((((unsigned long)(p)) & (sizeof (t)-1)) == 0) +#define is2DEncoding(sp) (sp->b.groupoptions & GROUP3OPT_2DENCODING) +#define isAligned(p,t) ((((size_t)(p)) & (sizeof (t)-1)) == 0) /* * Group 3 and Group 4 Decoding. @@ -140,15 +136,15 @@ typedef struct { sp->bit = BitsAvail; \ sp->data = BitAcc; \ sp->EOLcnt = EOLcnt; \ - tif->tif_rawcc -= (tidata_t) cp - tif->tif_rawcp; \ - tif->tif_rawcp = (tidata_t) cp; \ + tif->tif_rawcc -= (tmsize_t)((uint8*) cp - tif->tif_rawcp); \ + tif->tif_rawcp = (uint8*) cp; \ } while (0) /* * Setup state for decoding a strip. */ static int -Fax3PreDecode(TIFF* tif, tsample_t s) +Fax3PreDecode(TIFF* tif, uint16 s) { Fax3CodecState* sp = DecoderState(tif); @@ -183,10 +179,10 @@ Fax3PreDecode(TIFF* tif, tsample_t s) static void Fax3Unexpected(const char* module, TIFF* tif, uint32 line, uint32 a0) { - TIFFErrorExt(tif->tif_clientdata, module, "%s: Bad code word at line %u of %s %u (x %u)", - tif->tif_name, line, isTiled(tif) ? "tile" : "strip", - (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip), - a0); + TIFFErrorExt(tif->tif_clientdata, module, "Bad code word at line %u of %s %u (x %u)", + line, isTiled(tif) ? "tile" : "strip", + (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip), + a0); } #define unexpected(table, a0) Fax3Unexpected(module, tif, sp->line, a0) @@ -194,33 +190,31 @@ static void Fax3Extension(const char* module, TIFF* tif, uint32 line, uint32 a0) { TIFFErrorExt(tif->tif_clientdata, module, - "%s: Uncompressed data (not supported) at line %u of %s %u (x %u)", - tif->tif_name, line, isTiled(tif) ? "tile" : "strip", - (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip), - a0); + "Uncompressed data (not supported) at line %u of %s %u (x %u)", + line, isTiled(tif) ? "tile" : "strip", + (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip), + a0); } #define extension(a0) Fax3Extension(module, tif, sp->line, a0) static void Fax3BadLength(const char* module, TIFF* tif, uint32 line, uint32 a0, uint32 lastx) { - TIFFWarningExt(tif->tif_clientdata, module, "%s: %s at line %u of %s %u (got %u, expected %u)", - tif->tif_name, - a0 < lastx ? "Premature EOL" : "Line length mismatch", - line, isTiled(tif) ? "tile" : "strip", - (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip), - a0, lastx); + TIFFWarningExt(tif->tif_clientdata, module, "%s at line %u of %s %u (got %u, expected %u)", + a0 < lastx ? "Premature EOL" : "Line length mismatch", + line, isTiled(tif) ? "tile" : "strip", + (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip), + a0, lastx); } #define badlength(a0,lastx) Fax3BadLength(module, tif, sp->line, a0, lastx) static void Fax3PrematureEOF(const char* module, TIFF* tif, uint32 line, uint32 a0) { - TIFFWarningExt(tif->tif_clientdata, module, "%s: Premature EOF at line %u of %s %u (x %u)", - tif->tif_name, - line, isTiled(tif) ? "tile" : "strip", - (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip), - a0); + TIFFWarningExt(tif->tif_clientdata, module, "Premature EOF at line %u of %s %u (x %u)", + line, isTiled(tif) ? "tile" : "strip", + (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip), + a0); } #define prematureEOF(a0) Fax3PrematureEOF(module, tif, sp->line, a0) @@ -230,14 +224,18 @@ Fax3PrematureEOF(const char* module, TIFF* tif, uint32 line, uint32 a0) * Decode the requested amount of G3 1D-encoded data. */ static int -Fax3Decode1D(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s) +Fax3Decode1D(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s) { DECLARE_STATE(tif, sp, "Fax3Decode1D"); - (void) s; + if (occ % sp->b.rowbytes) + { + TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read"); + return (-1); + } CACHE_STATE(tif, sp); thisrun = sp->curruns; - while ((long)occ > 0) { + while (occ > 0) { a0 = 0; RunLength = 0; pa = thisrun; @@ -269,14 +267,18 @@ Fax3Decode1D(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s) * Decode the requested amount of G3 2D-encoded data. */ static int -Fax3Decode2D(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s) +Fax3Decode2D(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s) { DECLARE_STATE_2D(tif, sp, "Fax3Decode2D"); int is1D; /* current line is 1d/2d-encoded */ - (void) s; + if (occ % sp->b.rowbytes) + { + TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read"); + return (-1); + } CACHE_STATE(tif, sp); - while ((long)occ > 0) { + while (occ > 0) { a0 = 0; RunLength = 0; pa = thisrun = sp->curruns; @@ -324,7 +326,7 @@ Fax3Decode2D(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s) * this is <8 bytes. We optimize the code here to reflect the * machine characteristics. */ -#if SIZEOF_LONG == 8 +#if SIZEOF_UNSIGNED_LONG == 8 # define FILL(n, cp) \ switch (n) { \ case 15:(cp)[14] = 0xff; case 14:(cp)[13] = 0xff; case 13: (cp)[12] = 0xff;\ @@ -452,6 +454,13 @@ _TIFFFax3fillruns(unsigned char* buf, uint32* runs, uint32* erun, uint32 lastx) #undef ZERO #undef FILL +static int +Fax3FixupTags(TIFF* tif) +{ + (void) tif; + return (1); +} + /* * Setup G3/G4-related compression/decompression state * before data is processed. This routine is called once @@ -462,14 +471,16 @@ _TIFFFax3fillruns(unsigned char* buf, uint32* runs, uint32* erun, uint32 lastx) static int Fax3SetupState(TIFF* tif) { + static const char module[] = "Fax3SetupState"; TIFFDirectory* td = &tif->tif_dir; Fax3BaseState* sp = Fax3State(tif); int needsRefLine; Fax3CodecState* dsp = (Fax3CodecState*) Fax3State(tif); - uint32 rowbytes, rowpixels, nruns; + tmsize_t rowbytes; + uint32 rowpixels, nruns; if (td->td_bitspersample != 1) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, + TIFFErrorExt(tif->tif_clientdata, module, "Bits/sample must be 1 for Group 3/4 encoding/decoding"); return (0); } @@ -483,8 +494,8 @@ Fax3SetupState(TIFF* tif) rowbytes = TIFFScanlineSize(tif); rowpixels = td->td_imagewidth; } - sp->rowbytes = (uint32) rowbytes; - sp->rowpixels = (uint32) rowpixels; + sp->rowbytes = rowbytes; + sp->rowpixels = rowpixels; /* * Allocate any additional space required for decoding/encoding. */ @@ -493,12 +504,29 @@ Fax3SetupState(TIFF* tif) td->td_compression == COMPRESSION_CCITTFAX4 ); - nruns = needsRefLine ? 2*TIFFroundup(rowpixels,32) : rowpixels; - nruns += 3; - dsp->runs = (uint32*) _TIFFCheckMalloc(tif, 2*nruns, sizeof (uint32), - "for Group 3/4 run arrays"); + /* + Assure that allocation computations do not overflow. + + TIFFroundup and TIFFSafeMultiply return zero on integer overflow + */ + dsp->runs=(uint32*) NULL; + nruns = TIFFroundup_32(rowpixels,32); + if (needsRefLine) { + nruns = TIFFSafeMultiply(uint32,nruns,2); + } + if ((nruns == 0) || (TIFFSafeMultiply(uint32,nruns,2) == 0)) { + TIFFErrorExt(tif->tif_clientdata, tif->tif_name, + "Row pixels integer overflow (rowpixels %u)", + rowpixels); + return (0); + } + dsp->runs = (uint32*) _TIFFCheckMalloc(tif, + TIFFSafeMultiply(uint32,nruns,2), + sizeof (uint32), + "for Group 3/4 run arrays"); if (dsp->runs == NULL) return (0); + memset( dsp->runs, 0, TIFFSafeMultiply(uint32,nruns,2)*sizeof(uint32)); dsp->curruns = dsp->runs; if (needsRefLine) dsp->refruns = dsp->runs + nruns; @@ -522,9 +550,8 @@ Fax3SetupState(TIFF* tif) */ esp->refline = (unsigned char*) _TIFFmalloc(rowbytes); if (esp->refline == NULL) { - TIFFErrorExt(tif->tif_clientdata, "Fax3SetupState", - "%s: No space for Group 3/4 reference line", - tif->tif_name); + TIFFErrorExt(tif->tif_clientdata, module, + "No space for Group 3/4 reference line"); return (0); } } else /* 1d encoding */ @@ -540,14 +567,14 @@ Fax3SetupState(TIFF* tif) #define Fax3FlushBits(tif, sp) { \ if ((tif)->tif_rawcc >= (tif)->tif_rawdatasize) \ (void) TIFFFlushData1(tif); \ - *(tif)->tif_rawcp++ = (tidataval_t) (sp)->data; \ + *(tif)->tif_rawcp++ = (uint8) (sp)->data; \ (tif)->tif_rawcc++; \ (sp)->data = 0, (sp)->bit = 8; \ } #define _FlushBits(tif) { \ if ((tif)->tif_rawcc >= (tif)->tif_rawdatasize) \ (void) TIFFFlushData1(tif); \ - *(tif)->tif_rawcp++ = (tidataval_t) data; \ + *(tif)->tif_rawcp++ = (uint8) data; \ (tif)->tif_rawcc++; \ data = 0, bit = 8; \ } @@ -559,6 +586,7 @@ static const int _msbmask[9] = length -= bit; \ _FlushBits(tif); \ } \ + assert( length < 9 ); \ data |= (bits & _msbmask[length]) << (bit - length); \ bit -= length; \ if (bit == 0) \ @@ -686,7 +714,7 @@ Fax3PutEOL(TIFF* tif) * Reset encoding state at the start of a strip. */ static int -Fax3PreEncode(TIFF* tif, tsample_t s) +Fax3PreEncode(TIFF* tif, uint16 s) { Fax3CodecState* sp = EncoderState(tif); @@ -776,7 +804,7 @@ static int32 find1span(unsigned char*, int32, int32); * table. The ``base'' of the bit string is supplied * along with the start+end bit indices. */ -static int32 +inline static int32 find0span(unsigned char* bp, int32 bs, int32 be) { int32 bits = be - bs; @@ -835,7 +863,7 @@ find0span(unsigned char* bp, int32 bs, int32 be) return (span); } -static int32 +inline static int32 find1span(unsigned char* bp, int32 bs, int32 be) { int32 bits = be - bs; @@ -1007,12 +1035,17 @@ Fax3Encode2DRow(TIFF* tif, unsigned char* bp, unsigned char* rp, uint32 bits) * Encode a buffer of pixels. */ static int -Fax3Encode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) +Fax3Encode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s) { + static const char module[] = "Fax3Encode"; Fax3CodecState* sp = EncoderState(tif); - (void) s; - while ((long)cc > 0) { + if (cc % sp->b.rowbytes) + { + TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be written"); + return (0); + } + while (cc > 0) { if ((sp->b.mode & FAXMODE_NOEOL) == 0) Fax3PutEOL(tif); if (is2DEncoding(sp)) { @@ -1022,7 +1055,7 @@ Fax3Encode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) sp->tag = G3_2D; } else { if (!Fax3Encode2DRow(tif, bp, sp->refline, - sp->b.rowpixels)) + sp->b.rowpixels)) return (0); sp->k--; } @@ -1084,11 +1117,6 @@ Fax3Cleanup(TIFF* tif) if (sp->refline) _TIFFfree(sp->refline); - if (Fax3State(tif)->subaddress) - _TIFFfree(Fax3State(tif)->subaddress); - if (Fax3State(tif)->faxdcs) - _TIFFfree(Fax3State(tif)->faxdcs); - _TIFFfree(tif->tif_data); tif->tif_data = NULL; @@ -1098,59 +1126,34 @@ Fax3Cleanup(TIFF* tif) #define FIELD_BADFAXLINES (FIELD_CODEC+0) #define FIELD_CLEANFAXDATA (FIELD_CODEC+1) #define FIELD_BADFAXRUN (FIELD_CODEC+2) -#define FIELD_RECVPARAMS (FIELD_CODEC+3) -#define FIELD_SUBADDRESS (FIELD_CODEC+4) -#define FIELD_RECVTIME (FIELD_CODEC+5) -#define FIELD_FAXDCS (FIELD_CODEC+6) #define FIELD_OPTIONS (FIELD_CODEC+7) -static const TIFFFieldInfo faxFieldInfo[] = { - { TIFFTAG_FAXMODE, 0, 0, TIFF_ANY, FIELD_PSEUDO, - FALSE, FALSE, "FaxMode" }, - { TIFFTAG_FAXFILLFUNC, 0, 0, TIFF_ANY, FIELD_PSEUDO, - FALSE, FALSE, "FaxFillFunc" }, - { TIFFTAG_BADFAXLINES, 1, 1, TIFF_LONG, FIELD_BADFAXLINES, - TRUE, FALSE, "BadFaxLines" }, - { TIFFTAG_BADFAXLINES, 1, 1, TIFF_SHORT, FIELD_BADFAXLINES, - TRUE, FALSE, "BadFaxLines" }, - { TIFFTAG_CLEANFAXDATA, 1, 1, TIFF_SHORT, FIELD_CLEANFAXDATA, - TRUE, FALSE, "CleanFaxData" }, - { TIFFTAG_CONSECUTIVEBADFAXLINES,1,1, TIFF_LONG, FIELD_BADFAXRUN, - TRUE, FALSE, "ConsecutiveBadFaxLines" }, - { TIFFTAG_CONSECUTIVEBADFAXLINES,1,1, TIFF_SHORT, FIELD_BADFAXRUN, - TRUE, FALSE, "ConsecutiveBadFaxLines" }, - { TIFFTAG_FAXRECVPARAMS, 1, 1, TIFF_LONG, FIELD_RECVPARAMS, - TRUE, FALSE, "FaxRecvParams" }, - { TIFFTAG_FAXSUBADDRESS, -1,-1, TIFF_ASCII, FIELD_SUBADDRESS, - TRUE, FALSE, "FaxSubAddress" }, - { TIFFTAG_FAXRECVTIME, 1, 1, TIFF_LONG, FIELD_RECVTIME, - TRUE, FALSE, "FaxRecvTime" }, - { TIFFTAG_FAXDCS, -1,-1, TIFF_ASCII, FIELD_FAXDCS, - TRUE, FALSE, "FaxDcs" }, -}; -static const TIFFFieldInfo fax3FieldInfo[] = { - { TIFFTAG_GROUP3OPTIONS, 1, 1, TIFF_LONG, FIELD_OPTIONS, - FALSE, FALSE, "Group3Options" }, +static const TIFFField faxFields[] = { + { TIFFTAG_FAXMODE, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE, "FaxMode", NULL }, + { TIFFTAG_FAXFILLFUNC, 0, 0, TIFF_ANY, 0, TIFF_SETGET_OTHER, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE, "FaxFillFunc", NULL }, + { TIFFTAG_BADFAXLINES, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UINT32, FIELD_BADFAXLINES, TRUE, FALSE, "BadFaxLines", NULL }, + { TIFFTAG_CLEANFAXDATA, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UINT16, FIELD_CLEANFAXDATA, TRUE, FALSE, "CleanFaxData", NULL }, + { TIFFTAG_CONSECUTIVEBADFAXLINES, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UINT32, FIELD_BADFAXRUN, TRUE, FALSE, "ConsecutiveBadFaxLines", NULL }}; +static const TIFFField fax3Fields[] = { + { TIFFTAG_GROUP3OPTIONS, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UINT32, FIELD_OPTIONS, FALSE, FALSE, "Group3Options", NULL }, }; -static const TIFFFieldInfo fax4FieldInfo[] = { - { TIFFTAG_GROUP4OPTIONS, 1, 1, TIFF_LONG, FIELD_OPTIONS, - FALSE, FALSE, "Group4Options" }, +static const TIFFField fax4Fields[] = { + { TIFFTAG_GROUP4OPTIONS, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UINT32, FIELD_OPTIONS, FALSE, FALSE, "Group4Options", NULL }, }; -#define N(a) (sizeof (a) / sizeof (a[0])) static int -Fax3VSetField(TIFF* tif, ttag_t tag, va_list ap) +Fax3VSetField(TIFF* tif, uint32 tag, va_list ap) { Fax3BaseState* sp = Fax3State(tif); - const TIFFFieldInfo* fip; + const TIFFField* fip; assert(sp != 0); assert(sp->vsetparent != 0); switch (tag) { case TIFFTAG_FAXMODE: - sp->mode = va_arg(ap, int); + sp->mode = (int) va_arg(ap, int); return 1; /* NB: pseudo tag */ case TIFFTAG_FAXFILLFUNC: DecoderState(tif)->fill = va_arg(ap, TIFFFaxFillFunc); @@ -1158,39 +1161,27 @@ Fax3VSetField(TIFF* tif, ttag_t tag, va_list ap) case TIFFTAG_GROUP3OPTIONS: /* XXX: avoid reading options if compression mismatches. */ if (tif->tif_dir.td_compression == COMPRESSION_CCITTFAX3) - sp->groupoptions = va_arg(ap, uint32); + sp->groupoptions = (uint32) va_arg(ap, uint32); break; case TIFFTAG_GROUP4OPTIONS: /* XXX: avoid reading options if compression mismatches. */ if (tif->tif_dir.td_compression == COMPRESSION_CCITTFAX4) - sp->groupoptions = va_arg(ap, uint32); + sp->groupoptions = (uint32) va_arg(ap, uint32); break; case TIFFTAG_BADFAXLINES: - sp->badfaxlines = va_arg(ap, uint32); + sp->badfaxlines = (uint32) va_arg(ap, uint32); break; case TIFFTAG_CLEANFAXDATA: - sp->cleanfaxdata = (uint16) va_arg(ap, int); + sp->cleanfaxdata = (uint16) va_arg(ap, uint16_vap); break; case TIFFTAG_CONSECUTIVEBADFAXLINES: - sp->badfaxrun = va_arg(ap, uint32); - break; - case TIFFTAG_FAXRECVPARAMS: - sp->recvparams = va_arg(ap, uint32); - break; - case TIFFTAG_FAXSUBADDRESS: - _TIFFsetString(&sp->subaddress, va_arg(ap, char*)); - break; - case TIFFTAG_FAXRECVTIME: - sp->recvtime = va_arg(ap, uint32); - break; - case TIFFTAG_FAXDCS: - _TIFFsetString(&sp->faxdcs, va_arg(ap, char*)); + sp->badfaxrun = (uint32) va_arg(ap, uint32); break; default: return (*sp->vsetparent)(tif, tag, ap); } - if ((fip = _TIFFFieldWithTag(tif, tag))) + if ((fip = TIFFFieldWithTag(tif, tag))) TIFFSetFieldBit(tif, fip->field_bit); else return 0; @@ -1200,7 +1191,7 @@ Fax3VSetField(TIFF* tif, ttag_t tag, va_list ap) } static int -Fax3VGetField(TIFF* tif, ttag_t tag, va_list ap) +Fax3VGetField(TIFF* tif, uint32 tag, va_list ap) { Fax3BaseState* sp = Fax3State(tif); @@ -1226,18 +1217,6 @@ Fax3VGetField(TIFF* tif, ttag_t tag, va_list ap) case TIFFTAG_CONSECUTIVEBADFAXLINES: *va_arg(ap, uint32*) = sp->badfaxrun; break; - case TIFFTAG_FAXRECVPARAMS: - *va_arg(ap, uint32*) = sp->recvparams; - break; - case TIFFTAG_FAXSUBADDRESS: - *va_arg(ap, char**) = sp->subaddress; - break; - case TIFFTAG_FAXRECVTIME: - *va_arg(ap, uint32*) = sp->recvtime; - break; - case TIFFTAG_FAXDCS: - *va_arg(ap, char**) = sp->faxdcs; - break; default: return (*sp->vgetparent)(tif, tag, ap); } @@ -1294,27 +1273,20 @@ Fax3PrintDir(TIFF* tif, FILE* fd, long flags) if (TIFFFieldSet(tif,FIELD_BADFAXRUN)) fprintf(fd, " Consecutive Bad Fax Lines: %lu\n", (unsigned long) sp->badfaxrun); - if (TIFFFieldSet(tif,FIELD_RECVPARAMS)) - fprintf(fd, " Fax Receive Parameters: %08lx\n", - (unsigned long) sp->recvparams); - if (TIFFFieldSet(tif,FIELD_SUBADDRESS)) - fprintf(fd, " Fax SubAddress: %s\n", sp->subaddress); - if (TIFFFieldSet(tif,FIELD_RECVTIME)) - fprintf(fd, " Fax Receive Time: %lu secs\n", - (unsigned long) sp->recvtime); - if (TIFFFieldSet(tif,FIELD_FAXDCS)) - fprintf(fd, " Fax DCS: %s\n", sp->faxdcs); + if (sp->printdir) + (*sp->printdir)(tif, fd, flags); } static int InitCCITTFax3(TIFF* tif) { + static const char module[] = "InitCCITTFax3"; Fax3BaseState* sp; /* * Merge codec-specific tag information. */ - if (!_TIFFMergeFieldInfo(tif, faxFieldInfo, N(faxFieldInfo))) { + if (!_TIFFMergeFields(tif, faxFields, TIFFArrayCount(faxFields))) { TIFFErrorExt(tif->tif_clientdata, "InitCCITTFax3", "Merging common CCITT Fax codec-specific tags failed"); return 0; @@ -1323,12 +1295,12 @@ InitCCITTFax3(TIFF* tif) /* * Allocate state block so tag methods have storage to record values. */ - tif->tif_data = (tidata_t) + tif->tif_data = (uint8*) _TIFFmalloc(sizeof (Fax3CodecState)); if (tif->tif_data == NULL) { - TIFFErrorExt(tif->tif_clientdata, "TIFFInitCCITTFax3", - "%s: No space for state block", tif->tif_name); + TIFFErrorExt(tif->tif_clientdata, module, + "No space for state block"); return (0); } @@ -1345,9 +1317,6 @@ InitCCITTFax3(TIFF* tif) sp->printdir = tif->tif_tagmethods.printdir; tif->tif_tagmethods.printdir = Fax3PrintDir; /* hook for codec tags */ sp->groupoptions = 0; - sp->recvparams = 0; - sp->subaddress = NULL; - sp->faxdcs = NULL; if (sp->rw_mode == O_RDONLY) /* FIXME: improve for in place update */ tif->tif_flags |= TIFF_NOBITREV; /* decoder does bit reversal */ @@ -1358,6 +1327,7 @@ InitCCITTFax3(TIFF* tif) /* * Install codec methods. */ + tif->tif_fixuptags = Fax3FixupTags; tif->tif_setupdecode = Fax3SetupState; tif->tif_predecode = Fax3PreDecode; tif->tif_decoderow = Fax3Decode1D; @@ -1383,7 +1353,8 @@ TIFFInitCCITTFax3(TIFF* tif, int scheme) /* * Merge codec-specific tag information. */ - if (!_TIFFMergeFieldInfo(tif, fax3FieldInfo, N(fax3FieldInfo))) { + if (!_TIFFMergeFields(tif, fax3Fields, + TIFFArrayCount(fax3Fields))) { TIFFErrorExt(tif->tif_clientdata, "TIFFInitCCITTFax3", "Merging CCITT Fax 3 codec-specific tags failed"); return 0; @@ -1402,18 +1373,22 @@ TIFFInitCCITTFax3(TIFF* tif, int scheme) * Compression Scheme Support. */ -#define SWAP(t,a,b) { t x; x = (a); (a) = (b); (b) = x; } +#define SWAP(t,a,b) { t x; x = (a); (a) = (b); (b) = x; } /* * Decode the requested amount of G4-encoded data. */ static int -Fax4Decode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s) +Fax4Decode(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s) { DECLARE_STATE_2D(tif, sp, "Fax4Decode"); - (void) s; + if (occ % sp->b.rowbytes) + { + TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read"); + return (-1); + } CACHE_STATE(tif, sp); - while ((long)occ > 0) { + while (occ > 0) { a0 = 0; RunLength = 0; pa = thisrun = sp->curruns; @@ -1439,12 +1414,12 @@ Fax4Decode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s) BADG4: #ifdef FAX3_DEBUG if( GetBits(13) != 0x1001 ) - fputs( "Bad RTC\n", stderr ); + fputs( "Bad EOFB\n", stderr ); #endif ClrBits( 13 ); (*sp->fill)(buf, thisrun, pa, lastx); UNCACHE_STATE(tif, sp); - return (-1); + return ( sp->line ? 1 : -1); /* don't error on badly-terminated strips */ } UNCACHE_STATE(tif, sp); return (1); @@ -1455,12 +1430,17 @@ Fax4Decode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s) * Encode the requested amount of data. */ static int -Fax4Encode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) +Fax4Encode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s) { + static const char module[] = "Fax4Encode"; Fax3CodecState *sp = EncoderState(tif); - (void) s; - while ((long)cc > 0) { + if (cc % sp->b.rowbytes) + { + TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be written"); + return (0); + } + while (cc > 0) { if (!Fax3Encode2DRow(tif, bp, sp->refline, sp->b.rowpixels)) return (0); _TIFFmemcpy(sp->refline, bp, sp->b.rowbytes); @@ -1491,7 +1471,8 @@ TIFFInitCCITTFax4(TIFF* tif, int scheme) /* * Merge codec-specific tag information. */ - if (!_TIFFMergeFieldInfo(tif, fax4FieldInfo, N(fax4FieldInfo))) { + if (!_TIFFMergeFields(tif, fax4Fields, + TIFFArrayCount(fax4Fields))) { TIFFErrorExt(tif->tif_clientdata, "TIFFInitCCITTFax4", "Merging CCITT Fax 4 codec-specific tags failed"); return 0; @@ -1521,15 +1502,19 @@ TIFFInitCCITTFax4(TIFF* tif, int scheme) * Decode the requested amount of RLE-encoded data. */ static int -Fax3DecodeRLE(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s) +Fax3DecodeRLE(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s) { DECLARE_STATE(tif, sp, "Fax3DecodeRLE"); int mode = sp->b.mode; - (void) s; + if (occ % sp->b.rowbytes) + { + TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read"); + return (-1); + } CACHE_STATE(tif, sp); thisrun = sp->curruns; - while ((long)occ > 0) { + while (occ > 0) { a0 = 0; RunLength = 0; pa = thisrun; @@ -1589,7 +1574,7 @@ TIFFInitCCITTRLEW(TIFF* tif, int scheme) if (InitCCITTFax3(tif)) { /* reuse G3 support */ tif->tif_decoderow = Fax3DecodeRLE; tif->tif_decodestrip = Fax3DecodeRLE; - tif->tif_decodetile = Fax3DecodeRLE; + tif->tif_decodetile = Fax3DecodeRLE; /* * Suppress RTC+EOLs when encoding and word-align data. */ @@ -1601,3 +1586,10 @@ TIFFInitCCITTRLEW(TIFF* tif, int scheme) #endif /* CCITT_SUPPORT */ /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_fax3.h b/src/3rdparty/libtiff/libtiff/tif_fax3.h index 030632f..b0f46c9 100644 --- a/src/3rdparty/libtiff/libtiff/tif_fax3.h +++ b/src/3rdparty/libtiff/libtiff/tif_fax3.h @@ -1,4 +1,4 @@ -/* $Id: tif_fax3.h,v 1.5 2005/12/12 09:23:11 dron Exp $ */ +/* $Id: tif_fax3.h,v 1.9 2011-03-10 20:23:07 fwarmerdam Exp $ */ /* * Copyright (c) 1990-1997 Sam Leffler @@ -52,7 +52,7 @@ * data in the run array as needed (e.g. to append zero runs to bring * the count up to a nice multiple). */ -typedef void (*TIFFFaxFillFunc)(unsigned char*, uint32*, uint32*, uint32); +typedef void (*TIFFFaxFillFunc)(unsigned char*, uint32*, uint32*, uint32); /* * The default run filler; made external for other decoders. @@ -60,36 +60,36 @@ typedef void (*TIFFFaxFillFunc)(unsigned char*, uint32*, uint32*, uint32); #if defined(__cplusplus) extern "C" { #endif -extern void _TIFFFax3fillruns(unsigned char*, uint32*, uint32*, uint32); +extern void _TIFFFax3fillruns(unsigned char*, uint32*, uint32*, uint32); #if defined(__cplusplus) } #endif /* finite state machine codes */ -#define S_Null 0 -#define S_Pass 1 -#define S_Horiz 2 -#define S_V0 3 -#define S_VR 4 -#define S_VL 5 -#define S_Ext 6 -#define S_TermW 7 -#define S_TermB 8 -#define S_MakeUpW 9 -#define S_MakeUpB 10 -#define S_MakeUp 11 -#define S_EOL 12 +#define S_Null 0 +#define S_Pass 1 +#define S_Horiz 2 +#define S_V0 3 +#define S_VR 4 +#define S_VL 5 +#define S_Ext 6 +#define S_TermW 7 +#define S_TermB 8 +#define S_MakeUpW 9 +#define S_MakeUpB 10 +#define S_MakeUp 11 +#define S_EOL 12 -typedef struct { /* state table entry */ - unsigned char State; /* see above */ - unsigned char Width; /* width of code in bits */ - uint32 Param; /* unsigned 32-bit run length in bits */ +typedef struct { /* state table entry */ + unsigned char State; /* see above */ + unsigned char Width; /* width of code in bits */ + uint32 Param; /* unsigned 32-bit run length in bits */ } TIFFFaxTabEnt; -extern const TIFFFaxTabEnt TIFFFaxMainTable[]; -extern const TIFFFaxTabEnt TIFFFaxWhiteTable[]; -extern const TIFFFaxTabEnt TIFFFaxBlackTable[]; +extern const TIFFFaxTabEnt TIFFFaxMainTable[]; +extern const TIFFFaxTabEnt TIFFFaxWhiteTable[]; +extern const TIFFFaxTabEnt TIFFFaxBlackTable[]; /* * The following macros define the majority of the G3/G4 decoder @@ -478,6 +478,12 @@ done1d: \ break; \ case S_VL: \ CHECK_b1; \ + if (b1 <= (int) (a0 + TabEnt->Param)) { \ + if (b1 < (int) (a0 + TabEnt->Param) || pa != thisrun) { \ + unexpected("VL", a0); \ + goto eol2d; \ + } \ + } \ SETVALUE(b1 - a0 - TabEnt->Param); \ b1 -= *--pb; \ break; \ @@ -523,3 +529,10 @@ eol2d: \ CLEANUP_RUNS(); \ } while (0) #endif /* _FAX3_ */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_fax3sm.c b/src/3rdparty/libtiff/libtiff/tif_fax3sm.c index 08ce1ad..822191e 100644 --- a/src/3rdparty/libtiff/libtiff/tif_fax3sm.c +++ b/src/3rdparty/libtiff/libtiff/tif_fax3sm.c @@ -1251,3 +1251,10 @@ {8,4,6},{8,2,3},{8,3,4},{8,2,2},{8,5,7},{8,2,3},{8,3,1},{8,2,2},{8,4,5},{8,2,3}, {8,3,4},{8,2,2} }; +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_flush.c b/src/3rdparty/libtiff/libtiff/tif_flush.c index 5ff56e9..fd14e4cd 100644 --- a/src/3rdparty/libtiff/libtiff/tif_flush.c +++ b/src/3rdparty/libtiff/libtiff/tif_flush.c @@ -1,4 +1,4 @@ -/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_flush.c,v 1.3 2000/09/15 20:52:42 warmerda Exp $ */ +/* $Id: tif_flush.c,v 1.9 2010-03-31 06:40:10 fwarmerdam Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler @@ -32,15 +32,58 @@ int TIFFFlush(TIFF* tif) { + if( tif->tif_mode == O_RDONLY ) + return 1; - if (tif->tif_mode != O_RDONLY) { - if (!TIFFFlushData(tif)) - return (0); - if ((tif->tif_flags & TIFF_DIRTYDIRECT) && - !TIFFWriteDirectory(tif)) - return (0); - } - return (1); + if (!TIFFFlushData(tif)) + return (0); + + /* In update (r+) mode we try to detect the case where + only the strip/tile map has been altered, and we try to + rewrite only that portion of the directory without + making any other changes */ + + if( (tif->tif_flags & TIFF_DIRTYSTRIP) + && !(tif->tif_flags & TIFF_DIRTYDIRECT) + && tif->tif_mode == O_RDWR ) + { + uint64 *offsets=NULL, *sizes=NULL; + + if( TIFFIsTiled(tif) ) + { + if( TIFFGetField( tif, TIFFTAG_TILEOFFSETS, &offsets ) + && TIFFGetField( tif, TIFFTAG_TILEBYTECOUNTS, &sizes ) + && _TIFFRewriteField( tif, TIFFTAG_TILEOFFSETS, TIFF_LONG8, + tif->tif_dir.td_nstrips, offsets ) + && _TIFFRewriteField( tif, TIFFTAG_TILEBYTECOUNTS, TIFF_LONG8, + tif->tif_dir.td_nstrips, sizes ) ) + { + tif->tif_flags &= ~TIFF_DIRTYSTRIP; + tif->tif_flags &= ~TIFF_BEENWRITING; + return 1; + } + } + else + { + if( TIFFGetField( tif, TIFFTAG_STRIPOFFSETS, &offsets ) + && TIFFGetField( tif, TIFFTAG_STRIPBYTECOUNTS, &sizes ) + && _TIFFRewriteField( tif, TIFFTAG_STRIPOFFSETS, TIFF_LONG8, + tif->tif_dir.td_nstrips, offsets ) + && _TIFFRewriteField( tif, TIFFTAG_STRIPBYTECOUNTS, TIFF_LONG8, + tif->tif_dir.td_nstrips, sizes ) ) + { + tif->tif_flags &= ~TIFF_DIRTYSTRIP; + tif->tif_flags &= ~TIFF_BEENWRITING; + return 1; + } + } + } + + if ((tif->tif_flags & (TIFF_DIRTYDIRECT|TIFF_DIRTYSTRIP)) + && !TIFFRewriteDirectory(tif)) + return (0); + + return (1); } /* @@ -56,7 +99,7 @@ int TIFFFlushData(TIFF* tif) { if ((tif->tif_flags & TIFF_BEENWRITING) == 0) - return (0); + return (1); if (tif->tif_flags & TIFF_POSTENCODE) { tif->tif_flags &= ~TIFF_POSTENCODE; if (!(*tif->tif_postencode)(tif)) @@ -65,3 +108,11 @@ TIFFFlushData(TIFF* tif) return (TIFFFlushData1(tif)); } +/* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_getimage.c b/src/3rdparty/libtiff/libtiff/tif_getimage.c index 667f323..a85273c 100644 --- a/src/3rdparty/libtiff/libtiff/tif_getimage.c +++ b/src/3rdparty/libtiff/libtiff/tif_getimage.c @@ -1,4 +1,4 @@ -/* $Id: tif_getimage.c,v 1.63.2.3 2009-08-30 16:21:46 bfriesen Exp $ */ +/* $Id: tif_getimage.c,v 1.82 2012-06-06 00:17:49 fwarmerdam Exp $ */ /* * Copyright (c) 1991-1997 Sam Leffler @@ -38,6 +38,10 @@ static int gtStripContig(TIFFRGBAImage*, uint32*, uint32, uint32); static int gtStripSeparate(TIFFRGBAImage*, uint32*, uint32, uint32); static int PickContigCase(TIFFRGBAImage*); static int PickSeparateCase(TIFFRGBAImage*); + +static int BuildMapUaToAa(TIFFRGBAImage* img); +static int BuildMapBitdepth16To8(TIFFRGBAImage* img); + static const char photoTag[] = "PhotometricInterpretation"; /* @@ -50,7 +54,7 @@ static const char photoTag[] = "PhotometricInterpretation"; * Color conversion constants. We will define display types here. */ -TIFFDisplay display_sRGB = { +static const TIFFDisplay display_sRGB = { { /* XYZ -> luminance matrix */ { 3.2410F, -1.5374F, -0.4986F }, { -0.9692F, 1.8760F, 0.0416F }, @@ -202,10 +206,16 @@ TIFFRGBAImageEnd(TIFFRGBAImage* img) _TIFFfree(img->ycbcr), img->ycbcr = NULL; if (img->cielab) _TIFFfree(img->cielab), img->cielab = NULL; + if (img->UaToAa) + _TIFFfree(img->UaToAa), img->UaToAa = NULL; + if (img->Bitdepth16To8) + _TIFFfree(img->Bitdepth16To8), img->Bitdepth16To8 = NULL; + if( img->redcmap ) { _TIFFfree( img->redcmap ); _TIFFfree( img->greencmap ); _TIFFfree( img->bluecmap ); + img->redcmap = img->greencmap = img->bluecmap = NULL; } } @@ -252,7 +262,7 @@ TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024]) default: sprintf(emsg, "Sorry, can not handle images with %d-bit samples", img->bitspersample); - return (0); + goto fail_return; } img->alpha = 0; TIFFGetFieldDefaulted(tif, TIFFTAG_SAMPLESPERPIXEL, &img->samplesperpixel); @@ -301,7 +311,7 @@ TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024]) break; default: sprintf(emsg, "Missing needed %s tag", photoTag); - return (0); + goto fail_return; } } switch (img->photometric) { @@ -309,7 +319,7 @@ TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024]) if (!TIFFGetField(tif, TIFFTAG_COLORMAP, &red_orig, &green_orig, &blue_orig)) { sprintf(emsg, "Missing required \"Colormap\" tag"); - return (0); + goto fail_return; } /* copy the colormaps so we can modify them */ @@ -319,7 +329,7 @@ TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024]) img->bluecmap = (uint16 *) _TIFFmalloc(sizeof(uint16)*n_color); if( !img->redcmap || !img->greencmap || !img->bluecmap ) { sprintf(emsg, "Out of memory for colormap copy"); - return (0); + goto fail_return; } _TIFFmemcpy( img->redcmap, red_orig, n_color * 2 ); @@ -338,7 +348,7 @@ TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024]) photoTag, img->photometric, "Samples/pixel", img->samplesperpixel, img->bitspersample); - return (0); + goto fail_return; } break; case PHOTOMETRIC_YCBCR: @@ -371,7 +381,7 @@ TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024]) if (colorchannels < 3) { sprintf(emsg, "Sorry, can not handle RGB image with %s=%d", "Color channels", colorchannels); - return (0); + goto fail_return; } break; case PHOTOMETRIC_SEPARATED: @@ -381,12 +391,12 @@ TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024]) if (inkset != INKSET_CMYK) { sprintf(emsg, "Sorry, can not handle separated image with %s=%d", "InkSet", inkset); - return (0); + goto fail_return; } if (img->samplesperpixel < 4) { sprintf(emsg, "Sorry, can not handle separated image with %s=%d", "Samples/pixel", img->samplesperpixel); - return (0); + goto fail_return; } } break; @@ -394,7 +404,7 @@ TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024]) if (compress != COMPRESSION_SGILOG) { sprintf(emsg, "Sorry, LogL data must have %s=%d", "Compression", COMPRESSION_SGILOG); - return (0); + goto fail_return; } TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_8BIT); img->photometric = PHOTOMETRIC_MINISBLACK; /* little white lie */ @@ -404,7 +414,7 @@ TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024]) if (compress != COMPRESSION_SGILOG && compress != COMPRESSION_SGILOG24) { sprintf(emsg, "Sorry, LogLuv data must have %s=%d or %d", "Compression", COMPRESSION_SGILOG, COMPRESSION_SGILOG24); - return (0); + goto fail_return; } if (planarconfig != PLANARCONFIG_CONTIG) { sprintf(emsg, "Sorry, can not handle LogLuv images with %s=%d", @@ -420,30 +430,39 @@ TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024]) default: sprintf(emsg, "Sorry, can not handle image with %s=%d", photoTag, img->photometric); - return (0); + goto fail_return; } img->Map = NULL; img->BWmap = NULL; img->PALmap = NULL; img->ycbcr = NULL; img->cielab = NULL; + img->UaToAa = NULL; + img->Bitdepth16To8 = NULL; TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &img->width); TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &img->height); TIFFGetFieldDefaulted(tif, TIFFTAG_ORIENTATION, &img->orientation); img->isContig = - !(planarconfig == PLANARCONFIG_SEPARATE && colorchannels > 1); + !(planarconfig == PLANARCONFIG_SEPARATE && img->samplesperpixel > 1); if (img->isContig) { if (!PickContigCase(img)) { sprintf(emsg, "Sorry, can not handle image"); - return 0; + goto fail_return; } } else { if (!PickSeparateCase(img)) { sprintf(emsg, "Sorry, can not handle image"); - return 0; + goto fail_return; } } return 1; + + fail_return: + _TIFFfree( img->redcmap ); + _TIFFfree( img->greencmap ); + _TIFFfree( img->bluecmap ); + img->redcmap = img->greencmap = img->bluecmap = NULL; + return 0; } int @@ -572,7 +591,7 @@ gtTileContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h) TIFF* tif = img->tif; tileContigRoutine put = img->put.contig; uint32 col, row, y, rowstoread; - uint32 pos; + tmsize_t pos; uint32 tw, th; unsigned char* buf; int32 fromskew, toskew; @@ -581,7 +600,7 @@ gtTileContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h) buf = (unsigned char*) _TIFFmalloc(TIFFTileSize(tif)); if (buf == 0) { - TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for tile buffer"); + TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "%s", "No space for tile buffer"); return (0); } _TIFFmemset(buf, 0, TIFFTileSize(tif)); @@ -604,14 +623,14 @@ gtTileContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h) nrow = (row + rowstoread > h ? h - row : rowstoread); for (col = 0; col < w; col += tw) { - if (TIFFReadTile(tif, buf, col+img->col_offset, - row+img->row_offset, 0, 0) < 0 && img->stoponerr) + if (TIFFReadTile(tif, buf, col+img->col_offset, + row+img->row_offset, 0, 0)==(tmsize_t)(-1) && img->stoponerr) { ret = 0; break; } - pos = ((row+img->row_offset) % th) * TIFFTileRowSize(tif); + pos = ((row+img->row_offset) % th) * TIFFTileRowSize(tif); if (col + tw > w) { @@ -665,26 +684,33 @@ gtTileSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h) TIFF* tif = img->tif; tileSeparateRoutine put = img->put.separate; uint32 col, row, y, rowstoread; - uint32 pos; + tmsize_t pos; uint32 tw, th; unsigned char* buf; unsigned char* p0; unsigned char* p1; unsigned char* p2; unsigned char* pa; - tsize_t tilesize; + tmsize_t tilesize; + tmsize_t bufsize; int32 fromskew, toskew; int alpha = img->alpha; uint32 nrow; int ret = 1, flip; + int colorchannels; - tilesize = TIFFTileSize(tif); - buf = (unsigned char*) _TIFFmalloc((alpha?4:3)*tilesize); + tilesize = TIFFTileSize(tif); + bufsize = TIFFSafeMultiply(tmsize_t,alpha?4:3,tilesize); + if (bufsize == 0) { + TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "Integer overflow in %s", "gtTileSeparate"); + return (0); + } + buf = (unsigned char*) _TIFFmalloc(bufsize); if (buf == 0) { - TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for tile buffer"); + TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "%s", "No space for tile buffer"); return (0); } - _TIFFmemset(buf, 0, (alpha?4:3)*tilesize); + _TIFFmemset(buf, 0, bufsize); p0 = buf; p1 = p0 + tilesize; p2 = p1 + tilesize; @@ -702,41 +728,58 @@ gtTileSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h) toskew = -(int32)(tw - w); } + switch( img->photometric ) + { + case PHOTOMETRIC_MINISWHITE: + case PHOTOMETRIC_MINISBLACK: + case PHOTOMETRIC_PALETTE: + colorchannels = 1; + p2 = p1 = p0; + break; + + default: + colorchannels = 3; + break; + } + for (row = 0; row < h; row += nrow) { rowstoread = th - (row + img->row_offset) % th; nrow = (row + rowstoread > h ? h - row : rowstoread); for (col = 0; col < w; col += tw) { - if (TIFFReadTile(tif, p0, col+img->col_offset, - row+img->row_offset,0,0) < 0 && img->stoponerr) + if (TIFFReadTile(tif, p0, col+img->col_offset, + row+img->row_offset,0,0)==(tmsize_t)(-1) && img->stoponerr) { ret = 0; break; } - if (TIFFReadTile(tif, p1, col+img->col_offset, - row+img->row_offset,0,1) < 0 && img->stoponerr) + if (colorchannels > 1 + && TIFFReadTile(tif, p1, col+img->col_offset, + row+img->row_offset,0,1) == (tmsize_t)(-1) + && img->stoponerr) { ret = 0; break; } - if (TIFFReadTile(tif, p2, col+img->col_offset, - row+img->row_offset,0,2) < 0 && img->stoponerr) + if (colorchannels > 1 + && TIFFReadTile(tif, p2, col+img->col_offset, + row+img->row_offset,0,2) == (tmsize_t)(-1) + && img->stoponerr) { ret = 0; break; } - if (alpha) - { - if (TIFFReadTile(tif,pa,col+img->col_offset, - row+img->row_offset,0,3) < 0 && img->stoponerr) - { - ret = 0; - break; - } + if (alpha + && TIFFReadTile(tif,pa,col+img->col_offset, + row+img->row_offset,0,colorchannels) == (tmsize_t)(-1) + && img->stoponerr) + { + ret = 0; + break; } - pos = ((row+img->row_offset) % th) * TIFFTileRowSize(tif); + pos = ((row+img->row_offset) % th) * TIFFTileRowSize(tif); if (col + tw > w) { @@ -790,12 +833,12 @@ gtStripContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h) TIFF* tif = img->tif; tileContigRoutine put = img->put.contig; uint32 row, y, nrow, nrowsub, rowstoread; - uint32 pos; + tmsize_t pos; unsigned char* buf; uint32 rowsperstrip; uint16 subsamplinghor,subsamplingver; uint32 imagewidth = img->width; - tsize_t scanline; + tmsize_t scanline; int32 fromskew, toskew; int ret = 1, flip; @@ -817,7 +860,7 @@ gtStripContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h) TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip); TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING, &subsamplinghor, &subsamplingver); - scanline = TIFFNewScanlineSize(tif); + scanline = TIFFScanlineSize(tif); fromskew = (w < imagewidth ? imagewidth - w : 0); for (row = 0; row < h; row += nrow) { @@ -829,7 +872,7 @@ gtStripContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h) if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif,row+img->row_offset, 0), buf, - ((row + img->row_offset)%rowsperstrip + nrowsub) * scanline) < 0 + ((row + img->row_offset)%rowsperstrip + nrowsub) * scanline)==(tmsize_t)(-1) && img->stoponerr) { ret = 0; @@ -875,22 +918,28 @@ gtStripSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h) unsigned char *buf; unsigned char *p0, *p1, *p2, *pa; uint32 row, y, nrow, rowstoread; - uint32 pos; - tsize_t scanline; + tmsize_t pos; + tmsize_t scanline; uint32 rowsperstrip, offset_row; uint32 imagewidth = img->width; - tsize_t stripsize; + tmsize_t stripsize; + tmsize_t bufsize; int32 fromskew, toskew; int alpha = img->alpha; - int ret = 1, flip; + int ret = 1, flip, colorchannels; - stripsize = TIFFStripSize(tif); - p0 = buf = (unsigned char *)_TIFFmalloc((alpha?4:3)*stripsize); + stripsize = TIFFStripSize(tif); + bufsize = TIFFSafeMultiply(tmsize_t,alpha?4:3,stripsize); + if (bufsize == 0) { + TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "Integer overflow in %s", "gtStripSeparate"); + return (0); + } + p0 = buf = (unsigned char *)_TIFFmalloc(bufsize); if (buf == 0) { TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for tile buffer"); return (0); } - _TIFFmemset(buf, 0, (alpha?4:3)*stripsize); + _TIFFmemset(buf, 0, bufsize); p1 = p0 + stripsize; p2 = p1 + stripsize; pa = (alpha?(p2+stripsize):NULL); @@ -905,8 +954,22 @@ gtStripSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h) toskew = -(int32)(w - w); } + switch( img->photometric ) + { + case PHOTOMETRIC_MINISWHITE: + case PHOTOMETRIC_MINISBLACK: + case PHOTOMETRIC_PALETTE: + colorchannels = 1; + p2 = p1 = p0; + break; + + default: + colorchannels = 3; + break; + } + TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip); - scanline = TIFFScanlineSize(tif); + scanline = TIFFScanlineSize(tif); fromskew = (w < imagewidth ? imagewidth - w : 0); for (row = 0; row < h; row += nrow) { @@ -914,21 +977,23 @@ gtStripSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h) nrow = (row + rowstoread > h ? h - row : rowstoread); offset_row = row + img->row_offset; if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 0), - p0, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) < 0 + p0, ((row + img->row_offset)%rowsperstrip + nrow) * scanline)==(tmsize_t)(-1) && img->stoponerr) { ret = 0; break; } - if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 1), - p1, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) < 0 + if (colorchannels > 1 + && TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 1), + p1, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) == (tmsize_t)(-1) && img->stoponerr) { ret = 0; break; } - if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 2), - p2, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) < 0 + if (colorchannels > 1 + && TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 2), + p2, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) == (tmsize_t)(-1) && img->stoponerr) { ret = 0; @@ -936,8 +1001,8 @@ gtStripSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h) } if (alpha) { - if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 3), - pa, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) < 0 + if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, colorchannels), + pa, ((row + img->row_offset)%rowsperstrip + nrow) * scanline)==(tmsize_t)(-1) && img->stoponerr) { ret = 0; @@ -1036,6 +1101,7 @@ gtStripSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h) #define PACK4(r,g,b,a) \ ((uint32)(r)|((uint32)(g)<<8)|((uint32)(b)<<16)|((uint32)(a)<<24)) #define W2B(v) (((v)>>8)&0xff) +/* TODO: PACKW should have be made redundant in favor of Bitdepth16To8 LUT */ #define PACKW(r,g,b) \ ((uint32)W2B(r)|((uint32)W2B(g)<<8)|((uint32)W2B(b)<<16)|A1) #define PACKW4(r,g,b,a) \ @@ -1143,6 +1209,26 @@ DECLAREContigPutFunc(putgreytile) } /* + * 8-bit greyscale with associated alpha => colormap/RGBA + */ +DECLAREContigPutFunc(putagreytile) +{ + int samplesperpixel = img->samplesperpixel; + uint32** BWmap = img->BWmap; + + (void) y; + while (h-- > 0) { + for (x = w; x-- > 0;) + { + *cp++ = BWmap[*pp][0] & (*(pp+1) << 24 | ~A1); + pp += samplesperpixel; + } + cp += toskew; + pp += fromskew; + } +} + +/* * 16-bit greyscale => colormap/RGB */ DECLAREContigPutFunc(put16bitbwtile) @@ -1266,11 +1352,13 @@ DECLAREContigPutFunc(putRGBUAcontig8bittile) fromskew *= samplesperpixel; while (h-- > 0) { uint32 r, g, b, a; + uint8* m; for (x = w; x-- > 0;) { a = pp[3]; - r = (a*pp[0] + 127) / 255; - g = (a*pp[1] + 127) / 255; - b = (a*pp[2] + 127) / 255; + m = img->UaToAa+(a<<8); + r = m[pp[0]]; + g = m[pp[1]]; + b = m[pp[2]]; *cp++ = PACK4(r,g,b,a); pp += samplesperpixel; } @@ -1290,8 +1378,10 @@ DECLAREContigPutFunc(putRGBcontig16bittile) fromskew *= samplesperpixel; while (h-- > 0) { for (x = w; x-- > 0;) { - *cp++ = PACKW(wp[0],wp[1],wp[2]); - wp += samplesperpixel; + *cp++ = PACK(img->Bitdepth16To8[wp[0]], + img->Bitdepth16To8[wp[1]], + img->Bitdepth16To8[wp[2]]); + wp += samplesperpixel; } cp += toskew; wp += fromskew; @@ -1310,8 +1400,11 @@ DECLAREContigPutFunc(putRGBAAcontig16bittile) fromskew *= samplesperpixel; while (h-- > 0) { for (x = w; x-- > 0;) { - *cp++ = PACKW4(wp[0],wp[1],wp[2],wp[3]); - wp += samplesperpixel; + *cp++ = PACK4(img->Bitdepth16To8[wp[0]], + img->Bitdepth16To8[wp[1]], + img->Bitdepth16To8[wp[2]], + img->Bitdepth16To8[wp[3]]); + wp += samplesperpixel; } cp += toskew; wp += fromskew; @@ -1330,13 +1423,15 @@ DECLAREContigPutFunc(putRGBUAcontig16bittile) fromskew *= samplesperpixel; while (h-- > 0) { uint32 r,g,b,a; + uint8* m; for (x = w; x-- > 0;) { - a = W2B(wp[3]); - r = (a*W2B(wp[0]) + 127) / 255; - g = (a*W2B(wp[1]) + 127) / 255; - b = (a*W2B(wp[2]) + 127) / 255; - *cp++ = PACK4(r,g,b,a); - wp += samplesperpixel; + a = img->Bitdepth16To8[wp[3]]; + m = img->UaToAa+(a<<8); + r = m[img->Bitdepth16To8[wp[0]]]; + g = m[img->Bitdepth16To8[wp[1]]]; + b = m[img->Bitdepth16To8[wp[2]]]; + *cp++ = PACK4(r,g,b,a); + wp += samplesperpixel; } cp += toskew; wp += fromskew; @@ -1423,7 +1518,7 @@ DECLARESepPutFunc(putRGBseparate8bittile) */ DECLARESepPutFunc(putRGBAAseparate8bittile) { - (void) img; (void) x; (void) y; + (void) img; (void) x; (void) y; while (h-- > 0) { UNROLL8(w, NOP, *cp++ = PACK4(*r++, *g++, *b++, *a++)); SKEW4(r, g, b, a, fromskew); @@ -1432,6 +1527,26 @@ DECLARESepPutFunc(putRGBAAseparate8bittile) } /* + * 8-bit unpacked CMYK samples => RGBA + */ +DECLARESepPutFunc(putCMYKseparate8bittile) +{ + (void) img; (void) y; + while (h-- > 0) { + uint32 rv, gv, bv, kv; + for (x = w; x-- > 0;) { + kv = 255 - *a++; + rv = (kv*(255-*r++))/255; + gv = (kv*(255-*g++))/255; + bv = (kv*(255-*b++))/255; + *cp++ = PACK4(rv,gv,bv,255); + } + SKEW4(r, g, b, a, fromskew); + cp += toskew; + } +} + +/* * 8-bit unpacked samples => RGBA w/ unassociated alpha */ DECLARESepPutFunc(putRGBUAseparate8bittile) @@ -1439,11 +1554,13 @@ DECLARESepPutFunc(putRGBUAseparate8bittile) (void) img; (void) y; while (h-- > 0) { uint32 rv, gv, bv, av; + uint8* m; for (x = w; x-- > 0;) { av = *a++; - rv = (av* *r++ + 127) / 255; - gv = (av* *g++ + 127) / 255; - bv = (av* *b++ + 127) / 255; + m = img->UaToAa+(av<<8); + rv = m[*r++]; + gv = m[*g++]; + bv = m[*b++]; *cp++ = PACK4(rv,gv,bv,av); } SKEW4(r, g, b, a, fromskew); @@ -1462,7 +1579,9 @@ DECLARESepPutFunc(putRGBseparate16bittile) (void) img; (void) y; (void) a; while (h-- > 0) { for (x = 0; x < w; x++) - *cp++ = PACKW(*wr++,*wg++,*wb++); + *cp++ = PACK(img->Bitdepth16To8[*wr++], + img->Bitdepth16To8[*wg++], + img->Bitdepth16To8[*wb++]); SKEW(wr, wg, wb, fromskew); cp += toskew; } @@ -1480,7 +1599,10 @@ DECLARESepPutFunc(putRGBAAseparate16bittile) (void) img; (void) y; while (h-- > 0) { for (x = 0; x < w; x++) - *cp++ = PACKW4(*wr++,*wg++,*wb++,*wa++); + *cp++ = PACK4(img->Bitdepth16To8[*wr++], + img->Bitdepth16To8[*wg++], + img->Bitdepth16To8[*wb++], + img->Bitdepth16To8[*wa++]); SKEW4(wr, wg, wb, wa, fromskew); cp += toskew; } @@ -1498,12 +1620,14 @@ DECLARESepPutFunc(putRGBUAseparate16bittile) (void) img; (void) y; while (h-- > 0) { uint32 r,g,b,a; + uint8* m; for (x = w; x-- > 0;) { - a = W2B(*wa++); - r = (a*W2B(*wr++) + 127) / 255; - g = (a*W2B(*wg++) + 127) / 255; - b = (a*W2B(*wb++) + 127) / 255; - *cp++ = PACK4(r,g,b,a); + a = img->Bitdepth16To8[*wa++]; + m = img->UaToAa+(a<<8); + r = m[img->Bitdepth16To8[*wr++]]; + g = m[img->Bitdepth16To8[*wg++]]; + b = m[img->Bitdepth16To8[*wb++]]; + *cp++ = PACK4(r,g,b,a); } SKEW4(wr, wg, wb, wa, fromskew); cp += toskew; @@ -1846,6 +1970,7 @@ DECLAREContigPutFunc(putcontig8bitYCbCr41tile) DECLAREContigPutFunc(putcontig8bitYCbCr22tile) { uint32* cp2; + int32 incr = 2*toskew+w; (void) y; fromskew = (fromskew / 2) * 6; cp2 = cp+w+toskew; @@ -1872,8 +1997,8 @@ DECLAREContigPutFunc(putcontig8bitYCbCr22tile) cp2 ++ ; pp += 6; } - cp += toskew*2+w; - cp2 += toskew*2+w; + cp += incr; + cp2 += incr; pp += fromskew; h-=2; } @@ -1939,6 +2064,7 @@ DECLAREContigPutFunc(putcontig8bitYCbCr21tile) DECLAREContigPutFunc(putcontig8bitYCbCr12tile) { uint32* cp2; + int32 incr = 2*toskew+w; (void) y; fromskew = (fromskew / 2) * 4; cp2 = cp+w+toskew; @@ -1953,8 +2079,8 @@ DECLAREContigPutFunc(putcontig8bitYCbCr12tile) cp2 ++; pp += 4; } while (--x); - cp += toskew*2+w; - cp2 += toskew*2+w; + cp += incr; + cp2 += incr; pp += fromskew; h-=2; } @@ -2016,13 +2142,13 @@ DECLARESepPutFunc(putseparate8bitYCbCr11tile) static int initYCbCrConversion(TIFFRGBAImage* img) { - static char module[] = "initYCbCrConversion"; + static const char module[] = "initYCbCrConversion"; float *luma, *refBlackWhite; if (img->ycbcr == NULL) { img->ycbcr = (TIFFYCbCrToRGB*) _TIFFmalloc( - TIFFroundup(sizeof (TIFFYCbCrToRGB), sizeof (long)) + TIFFroundup_32(sizeof (TIFFYCbCrToRGB), sizeof (long)) + 4*256*sizeof (TIFFRGBValue) + 2*256*sizeof (int) + 3*256*sizeof (int32) @@ -2045,7 +2171,7 @@ initYCbCrConversion(TIFFRGBAImage* img) static tileContigRoutine initCIELabConversion(TIFFRGBAImage* img) { - static char module[] = "initCIELabConversion"; + static const char module[] = "initCIELabConversion"; float *whitePoint; float refWhite[3]; @@ -2325,23 +2451,28 @@ PickContigCase(TIFFRGBAImage* img) img->put.contig = putRGBAAcontig8bittile; else if (img->alpha == EXTRASAMPLE_UNASSALPHA) { - img->put.contig = putRGBUAcontig8bittile; + if (BuildMapUaToAa(img)) + img->put.contig = putRGBUAcontig8bittile; } else - img->put.contig = putRGBcontig8bittile; + img->put.contig = putRGBcontig8bittile; break; case 16: if (img->alpha == EXTRASAMPLE_ASSOCALPHA) { - img->put.contig = putRGBAAcontig16bittile; + if (BuildMapBitdepth16To8(img)) + img->put.contig = putRGBAAcontig16bittile; } else if (img->alpha == EXTRASAMPLE_UNASSALPHA) { - img->put.contig = putRGBUAcontig16bittile; + if (BuildMapBitdepth16To8(img) && + BuildMapUaToAa(img)) + img->put.contig = putRGBUAcontig16bittile; } else { - img->put.contig = putRGBcontig16bittile; + if (BuildMapBitdepth16To8(img)) + img->put.contig = putRGBcontig16bittile; } break; } @@ -2382,7 +2513,10 @@ PickContigCase(TIFFRGBAImage* img) img->put.contig = put16bitbwtile; break; case 8: - img->put.contig = putgreytile; + if (img->alpha && img->samplesperpixel == 2) + img->put.contig = putagreytile; + else + img->put.contig = putgreytile; break; case 4: img->put.contig = put4bitbwtile; @@ -2397,7 +2531,7 @@ PickContigCase(TIFFRGBAImage* img) } break; case PHOTOMETRIC_YCBCR: - if (img->bitspersample == 8) + if ((img->bitspersample==8) && (img->samplesperpixel==3)) { if (initYCbCrConversion(img)!=0) { @@ -2461,54 +2595,111 @@ PickSeparateCase(TIFFRGBAImage* img) img->get = TIFFIsTiled(img->tif) ? gtTileSeparate : gtStripSeparate; img->put.separate = NULL; switch (img->photometric) { - case PHOTOMETRIC_RGB: - switch (img->bitspersample) { - case 8: - if (img->alpha == EXTRASAMPLE_ASSOCALPHA) - img->put.separate = putRGBAAseparate8bittile; - else if (img->alpha == EXTRASAMPLE_UNASSALPHA) - { - img->put.separate = putRGBUAseparate8bittile; - } - else - img->put.separate = putRGBseparate8bittile; - break; - case 16: - if (img->alpha == EXTRASAMPLE_ASSOCALPHA) - { - img->put.separate = putRGBAAseparate16bittile; - } - else if (img->alpha == EXTRASAMPLE_UNASSALPHA) - { - img->put.separate = putRGBUAseparate16bittile; - } - else - { - img->put.separate = putRGBseparate16bittile; - } - break; + case PHOTOMETRIC_MINISWHITE: + case PHOTOMETRIC_MINISBLACK: + /* greyscale images processed pretty much as RGB by gtTileSeparate */ + case PHOTOMETRIC_RGB: + switch (img->bitspersample) { + case 8: + if (img->alpha == EXTRASAMPLE_ASSOCALPHA) + img->put.separate = putRGBAAseparate8bittile; + else if (img->alpha == EXTRASAMPLE_UNASSALPHA) + { + if (BuildMapUaToAa(img)) + img->put.separate = putRGBUAseparate8bittile; } + else + img->put.separate = putRGBseparate8bittile; break; - case PHOTOMETRIC_YCBCR: - if ((img->bitspersample==8) && (img->samplesperpixel==3)) + case 16: + if (img->alpha == EXTRASAMPLE_ASSOCALPHA) { - if (initYCbCrConversion(img)!=0) - { - uint16 hs, vs; - TIFFGetFieldDefaulted(img->tif, TIFFTAG_YCBCRSUBSAMPLING, &hs, &vs); - switch ((hs<<4)|vs) { - case 0x11: - img->put.separate = putseparate8bitYCbCr11tile; - break; - /* TODO: add other cases here */ - } - } + if (BuildMapBitdepth16To8(img)) + img->put.separate = putRGBAAseparate16bittile; + } + else if (img->alpha == EXTRASAMPLE_UNASSALPHA) + { + if (BuildMapBitdepth16To8(img) && + BuildMapUaToAa(img)) + img->put.separate = putRGBUAseparate16bittile; + } + else + { + if (BuildMapBitdepth16To8(img)) + img->put.separate = putRGBseparate16bittile; } break; + } + break; + case PHOTOMETRIC_SEPARATED: + if (img->bitspersample == 8 && img->samplesperpixel == 4) + { + img->alpha = 1; // Not alpha, but seems like the only way to get 4th band + img->put.separate = putCMYKseparate8bittile; + } + break; + case PHOTOMETRIC_YCBCR: + if ((img->bitspersample==8) && (img->samplesperpixel==3)) + { + if (initYCbCrConversion(img)!=0) + { + uint16 hs, vs; + TIFFGetFieldDefaulted(img->tif, TIFFTAG_YCBCRSUBSAMPLING, &hs, &vs); + switch ((hs<<4)|vs) { + case 0x11: + img->put.separate = putseparate8bitYCbCr11tile; + break; + /* TODO: add other cases here */ + } + } + } + break; } return ((img->get!=NULL) && (img->put.separate!=NULL)); } +static int +BuildMapUaToAa(TIFFRGBAImage* img) +{ + static const char module[]="BuildMapUaToAa"; + uint8* m; + uint16 na,nv; + assert(img->UaToAa==NULL); + img->UaToAa=_TIFFmalloc(65536); + if (img->UaToAa==NULL) + { + TIFFErrorExt(img->tif->tif_clientdata,module,"Out of memory"); + return(0); + } + m=img->UaToAa; + for (na=0; na<256; na++) + { + for (nv=0; nv<256; nv++) + *m++=(nv*na+127)/255; + } + return(1); +} + +static int +BuildMapBitdepth16To8(TIFFRGBAImage* img) +{ + static const char module[]="BuildMapBitdepth16To8"; + uint8* m; + uint32 n; + assert(img->Bitdepth16To8==NULL); + img->Bitdepth16To8=_TIFFmalloc(65536); + if (img->Bitdepth16To8==NULL) + { + TIFFErrorExt(img->tif->tif_clientdata,module,"Out of memory"); + return(0); + } + m=img->Bitdepth16To8; + for (n=0; n<65536; n++) + *m++=(n+128)/257; + return(1); +} + + /* * Read a whole strip off data from the file, and convert to RGBA form. * If this is the last strip, then it will only contain the portion of @@ -2667,3 +2858,10 @@ TIFFReadRGBATile(TIFF* tif, uint32 col, uint32 row, uint32 * raster) } /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_jbig.c b/src/3rdparty/libtiff/libtiff/tif_jbig.c index 99183ba..37878f6 100644 --- a/src/3rdparty/libtiff/libtiff/tif_jbig.c +++ b/src/3rdparty/libtiff/libtiff/tif_jbig.c @@ -1,26 +1,26 @@ -/* $Id: tif_jbig.c,v 1.2.2.2 2008-10-21 13:13:07 dron Exp $ */ +/* $Id: tif_jbig.c,v 1.15 2010-03-10 18:56:48 bfriesen Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * - * Permission to use, copy, modify, distribute, and sell this software and + * 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. - * + * + * 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 + * 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. */ @@ -29,7 +29,7 @@ * * JBIG Compression Algorithm Support. * Contributed by Lee Howard <faxguy@deanox.com> - * + * */ #include "tiffiop.h" @@ -37,342 +37,177 @@ #ifdef JBIG_SUPPORT #include "jbig.h" -typedef struct -{ - uint32 recvparams; /* encoded Class 2 session params */ - char* subaddress; /* subaddress string */ - uint32 recvtime; /* time spend receiving in seconds */ - char* faxdcs; /* encoded fax parameters (DCS, Table 2/T.30) */ - - TIFFVGetMethod vgetparent; - TIFFVSetMethod vsetparent; -} JBIGState; - -#define GetJBIGState(tif) ((JBIGState*)(tif)->tif_data) - -#define FIELD_RECVPARAMS (FIELD_CODEC+0) -#define FIELD_SUBADDRESS (FIELD_CODEC+1) -#define FIELD_RECVTIME (FIELD_CODEC+2) -#define FIELD_FAXDCS (FIELD_CODEC+3) - -static const TIFFFieldInfo jbigFieldInfo[] = -{ - {TIFFTAG_FAXRECVPARAMS, 1, 1, TIFF_LONG, FIELD_RECVPARAMS, TRUE, FALSE, "FaxRecvParams"}, - {TIFFTAG_FAXSUBADDRESS, -1, -1, TIFF_ASCII, FIELD_SUBADDRESS, TRUE, FALSE, "FaxSubAddress"}, - {TIFFTAG_FAXRECVTIME, 1, 1, TIFF_LONG, FIELD_RECVTIME, TRUE, FALSE, "FaxRecvTime"}, - {TIFFTAG_FAXDCS, -1, -1, TIFF_ASCII, FIELD_FAXDCS, TRUE, FALSE, "FaxDcs"}, -}; - static int JBIGSetupDecode(TIFF* tif) { - if (TIFFNumberOfStrips(tif) != 1) - { - TIFFError("JBIG", "Multistrip images not supported in decoder"); - return 0; - } + if (TIFFNumberOfStrips(tif) != 1) + { + TIFFErrorExt(tif->tif_clientdata, "JBIG", "Multistrip images not supported in decoder"); + return 0; + } - return 1; + return 1; } -static int JBIGDecode(TIFF* tif, tidata_t buffer, tsize_t size, tsample_t s) +static int JBIGDecode(TIFF* tif, uint8* buffer, tmsize_t size, uint16 s) { - struct jbg_dec_state decoder; - int decodeStatus = 0; - unsigned char* pImage = NULL; + struct jbg_dec_state decoder; + int decodeStatus = 0; + unsigned char* pImage = NULL; (void) size, (void) s; - if (isFillOrder(tif, tif->tif_dir.td_fillorder)) - { - TIFFReverseBits(tif->tif_rawdata, tif->tif_rawdatasize); - } + if (isFillOrder(tif, tif->tif_dir.td_fillorder)) + { + TIFFReverseBits(tif->tif_rawdata, tif->tif_rawdatasize); + } - jbg_dec_init(&decoder); + jbg_dec_init(&decoder); #if defined(HAVE_JBG_NEWLEN) - jbg_newlen(tif->tif_rawdata, tif->tif_rawdatasize); - /* - * I do not check the return status of jbg_newlen because even if this - * function fails it does not necessarily mean that decoding the image - * will fail. It is generally only needed for received fax images - * that do not contain the actual length of the image in the BIE - * header. I do not log when an error occurs because that will cause - * problems when converting JBIG encoded TIFF's to - * PostScript. As long as the actual image length is contained in the - * BIE header jbg_dec_in should succeed. - */ + jbg_newlen(tif->tif_rawdata, (size_t)tif->tif_rawdatasize); + /* + * I do not check the return status of jbg_newlen because even if this + * function fails it does not necessarily mean that decoding the image + * will fail. It is generally only needed for received fax images + * that do not contain the actual length of the image in the BIE + * header. I do not log when an error occurs because that will cause + * problems when converting JBIG encoded TIFF's to + * PostScript. As long as the actual image length is contained in the + * BIE header jbg_dec_in should succeed. + */ #endif /* HAVE_JBG_NEWLEN */ - decodeStatus = jbg_dec_in(&decoder, tif->tif_rawdata, - tif->tif_rawdatasize, NULL); - if (JBG_EOK != decodeStatus) - { + decodeStatus = jbg_dec_in(&decoder, (unsigned char*)tif->tif_rawdata, + (size_t)tif->tif_rawdatasize, NULL); + if (JBG_EOK != decodeStatus) + { /* * XXX: JBG_EN constant was defined in pre-2.0 releases of the * JBIG-KIT. Since the 2.0 the error reporting functions were * changed. We will handle both cases here. */ - TIFFError("JBIG", "Error (%d) decoding: %s", decodeStatus, + TIFFErrorExt(tif->tif_clientdata, + "JBIG", "Error (%d) decoding: %s", + decodeStatus, #if defined(JBG_EN) - jbg_strerror(decodeStatus, JBG_EN) + jbg_strerror(decodeStatus, JBG_EN) #else - jbg_strerror(decodeStatus) + jbg_strerror(decodeStatus) #endif - ); - return 0; - } - - pImage = jbg_dec_getimage(&decoder, 0); - _TIFFmemcpy(buffer, pImage, jbg_dec_getsize(&decoder)); - jbg_dec_free(&decoder); - return 1; -} - -static int JBIGSetupEncode(TIFF* tif) -{ - if (TIFFNumberOfStrips(tif) != 1) - { - TIFFError("JBIG", "Multistrip images not supported in encoder"); - return 0; - } - - return 1; -} + ); + return 0; + } -static int JBIGCopyEncodedData(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s) -{ - (void) s; - while (cc > 0) - { - tsize_t n = cc; - - if (tif->tif_rawcc + n > tif->tif_rawdatasize) - { - n = tif->tif_rawdatasize - tif->tif_rawcc; - } - - assert(n > 0); - _TIFFmemcpy(tif->tif_rawcp, pp, n); - tif->tif_rawcp += n; - tif->tif_rawcc += n; - pp += n; - cc -= n; - if (tif->tif_rawcc >= tif->tif_rawdatasize && - !TIFFFlushData1(tif)) - { - return (-1); - } - } - - return (1); + pImage = jbg_dec_getimage(&decoder, 0); + _TIFFmemcpy(buffer, pImage, jbg_dec_getsize(&decoder)); + jbg_dec_free(&decoder); + return 1; } -static void JBIGOutputBie(unsigned char* buffer, size_t len, void *userData) +static int JBIGSetupEncode(TIFF* tif) { - TIFF* tif = (TIFF*)userData; - - if (isFillOrder(tif, tif->tif_dir.td_fillorder)) - { - TIFFReverseBits(buffer, len); - } + if (TIFFNumberOfStrips(tif) != 1) + { + TIFFErrorExt(tif->tif_clientdata, "JBIG", "Multistrip images not supported in encoder"); + return 0; + } - JBIGCopyEncodedData(tif, buffer, len, 0); + return 1; } -static int JBIGEncode(TIFF* tif, tidata_t buffer, tsize_t size, tsample_t s) +static int JBIGCopyEncodedData(TIFF* tif, unsigned char* pp, size_t cc, uint16 s) { - TIFFDirectory* dir = &tif->tif_dir; - struct jbg_enc_state encoder; - - (void) size, (void) s; + (void) s; + while (cc > 0) + { + tmsize_t n = (tmsize_t)cc; + + if (tif->tif_rawcc + n > tif->tif_rawdatasize) + { + n = tif->tif_rawdatasize - tif->tif_rawcc; + } + + assert(n > 0); + _TIFFmemcpy(tif->tif_rawcp, pp, n); + tif->tif_rawcp += n; + tif->tif_rawcc += n; + pp += n; + cc -= (size_t)n; + if (tif->tif_rawcc >= tif->tif_rawdatasize && + !TIFFFlushData1(tif)) + { + return (-1); + } + } - jbg_enc_init(&encoder, - dir->td_imagewidth, - dir->td_imagelength, - 1, - &buffer, - JBIGOutputBie, - tif); - /* - * jbg_enc_out does the "real" encoding. As data is encoded, - * JBIGOutputBie is called, which writes the data to the directory. - */ - jbg_enc_out(&encoder); - jbg_enc_free(&encoder); - - return 1; + return (1); } -static void JBIGCleanup(TIFF* tif) +static void JBIGOutputBie(unsigned char* buffer, size_t len, void* userData) { - JBIGState *sp = GetJBIGState(tif); - - assert(sp != 0); - - tif->tif_tagmethods.vgetfield = sp->vgetparent; - tif->tif_tagmethods.vsetfield = sp->vsetparent; - - _TIFFfree(tif->tif_data); - tif->tif_data = NULL; + TIFF* tif = (TIFF*)userData; - _TIFFSetDefaultCompressionState(tif); -} - -static void JBIGPrintDir(TIFF* tif, FILE* fd, long flags) -{ - JBIGState* codec = GetJBIGState(tif); - (void)flags; - - if (TIFFFieldSet(tif, FIELD_RECVPARAMS)) - { - fprintf(fd, - " Fax Receive Parameters: %08lx\n", - (unsigned long)codec->recvparams); - } - - if (TIFFFieldSet(tif, FIELD_SUBADDRESS)) - { - fprintf(fd, - " Fax SubAddress: %s\n", - codec->subaddress); - } - - if (TIFFFieldSet(tif, FIELD_RECVTIME)) - { - fprintf(fd, - " Fax Receive Time: %lu secs\n", - (unsigned long)codec->recvtime); - } - - if (TIFFFieldSet(tif, FIELD_FAXDCS)) - { - fprintf(fd, - " Fax DCS: %s\n", - codec->faxdcs); - } -} + if (isFillOrder(tif, tif->tif_dir.td_fillorder)) + { + TIFFReverseBits(buffer, (tmsize_t)len); + } -static int JBIGVGetField(TIFF* tif, ttag_t tag, va_list ap) -{ - JBIGState* codec = GetJBIGState(tif); - - switch (tag) - { - case TIFFTAG_FAXRECVPARAMS: - *va_arg(ap, uint32*) = codec->recvparams; - break; - - case TIFFTAG_FAXSUBADDRESS: - *va_arg(ap, char**) = codec->subaddress; - break; - - case TIFFTAG_FAXRECVTIME: - *va_arg(ap, uint32*) = codec->recvtime; - break; - - case TIFFTAG_FAXDCS: - *va_arg(ap, char**) = codec->faxdcs; - break; - - default: - return (*codec->vgetparent)(tif, tag, ap); - } - - return 1; + JBIGCopyEncodedData(tif, buffer, len, 0); } -static int JBIGVSetField(TIFF* tif, ttag_t tag, va_list ap) +static int JBIGEncode(TIFF* tif, uint8* buffer, tmsize_t size, uint16 s) { - JBIGState* codec = GetJBIGState(tif); - - switch (tag) - { - case TIFFTAG_FAXRECVPARAMS: - codec->recvparams = va_arg(ap, uint32); - break; + TIFFDirectory* dir = &tif->tif_dir; + struct jbg_enc_state encoder; - case TIFFTAG_FAXSUBADDRESS: - _TIFFsetString(&codec->subaddress, va_arg(ap, char*)); - break; - - case TIFFTAG_FAXRECVTIME: - codec->recvtime = va_arg(ap, uint32); - break; - - case TIFFTAG_FAXDCS: - _TIFFsetString(&codec->faxdcs, va_arg(ap, char*)); - break; + (void) size, (void) s; - default: - return (*codec->vsetparent)(tif, tag, ap); - } + jbg_enc_init(&encoder, + dir->td_imagewidth, + dir->td_imagelength, + 1, + &buffer, + JBIGOutputBie, + tif); + /* + * jbg_enc_out does the "real" encoding. As data is encoded, + * JBIGOutputBie is called, which writes the data to the directory. + */ + jbg_enc_out(&encoder); + jbg_enc_free(&encoder); - TIFFSetFieldBit(tif, _TIFFFieldWithTag(tif, tag)->field_bit); - tif->tif_flags |= TIFF_DIRTYDIRECT; - return 1; + return 1; } int TIFFInitJBIG(TIFF* tif, int scheme) { - JBIGState* codec = NULL; - assert(scheme == COMPRESSION_JBIG); /* - * Merge codec-specific tag information. + * These flags are set so the JBIG Codec can control when to reverse + * bits and when not to and to allow the jbig decoder and bit reverser + * to write to memory when necessary. */ - if (!_TIFFMergeFieldInfo(tif, jbigFieldInfo, - TIFFArrayCount(jbigFieldInfo))) { - TIFFErrorExt(tif->tif_clientdata, "TIFFInitJBIG", - "Merging JBIG codec-specific tags failed"); - return 0; - } + tif->tif_flags |= TIFF_NOBITREV; + tif->tif_flags &= ~TIFF_MAPPED; - /* Allocate memory for the JBIGState structure.*/ - tif->tif_data = (tdata_t)_TIFFmalloc(sizeof(JBIGState)); - if (tif->tif_data == NULL) - { - TIFFError("TIFFInitJBIG", "Not enough memory for JBIGState"); - return 0; - } - _TIFFmemset(tif->tif_data, 0, sizeof(JBIGState)); - codec = GetJBIGState(tif); - - /* Initialize codec private fields */ - codec->recvparams = 0; - codec->subaddress = NULL; - codec->faxdcs = NULL; - codec->recvtime = 0; - - /* - * Override parent get/set field methods. - */ - codec->vgetparent = tif->tif_tagmethods.vgetfield; - codec->vsetparent = tif->tif_tagmethods.vsetfield; - tif->tif_tagmethods.vgetfield = JBIGVGetField; - tif->tif_tagmethods.vsetfield = JBIGVSetField; - tif->tif_tagmethods.printdir = JBIGPrintDir; - - /* - * These flags are set so the JBIG Codec can control when to reverse - * bits and when not to and to allow the jbig decoder and bit reverser - * to write to memory when necessary. - */ - tif->tif_flags |= TIFF_NOBITREV; - tif->tif_flags &= ~TIFF_MAPPED; - - /* Setup the function pointers for encode, decode, and cleanup. */ - tif->tif_setupdecode = JBIGSetupDecode; - tif->tif_decodestrip = JBIGDecode; - - tif->tif_setupencode = JBIGSetupEncode; - tif->tif_encodestrip = JBIGEncode; - - tif->tif_cleanup = JBIGCleanup; - - return 1; + /* Setup the function pointers for encode, decode, and cleanup. */ + tif->tif_setupdecode = JBIGSetupDecode; + tif->tif_decodestrip = JBIGDecode; + + tif->tif_setupencode = JBIGSetupEncode; + tif->tif_encodestrip = JBIGEncode; + + return 1; } #endif /* JBIG_SUPPORT */ /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_jpeg.c b/src/3rdparty/libtiff/libtiff/tif_jpeg.c index 74b0d3f..b61b91b 100644 --- a/src/3rdparty/libtiff/libtiff/tif_jpeg.c +++ b/src/3rdparty/libtiff/libtiff/tif_jpeg.c @@ -1,4 +1,4 @@ -/* $Id: tif_jpeg.c,v 1.50.2.4 2009-08-30 16:21:46 bfriesen Exp $ */ +/* $Id: tif_jpeg.c,v 1.111 2012-07-06 18:48:04 bfriesen Exp $ */ /* * Copyright (c) 1994-1997 Sam Leffler @@ -44,8 +44,9 @@ */ #include <setjmp.h> -int TIFFFillStrip(TIFF*, tstrip_t); -int TIFFFillTile(TIFF*, ttile_t); +int TIFFFillStrip(TIFF* tif, uint32 strip); +int TIFFFillTile(TIFF* tif, uint32 tile); +int TIFFReInitJPEG_12( TIFF *tif, int scheme, int is_encode ); /* We undefine FAR to avoid conflict with JPEG definition */ @@ -77,7 +78,7 @@ int TIFFFillTile(TIFF*, ttile_t); */ /* Define "boolean" as unsigned char, not int, per Windows custom. */ -#if defined(WIN32) && !defined(__MINGW32__) +#if defined(__WIN32__) && !defined(__MINGW32__) # ifndef __RPCNDR_H__ /* don't conflict if rpcndr.h already read */ typedef unsigned char boolean; # endif @@ -87,6 +88,17 @@ int TIFFFillTile(TIFF*, ttile_t); #include "jpeglib.h" #include "jerror.h" +/* + * Do we want to do special processing suitable for when JSAMPLE is a + * 16bit value? + */ + +#if defined(JPEG_LIB_MK1) +# define JPEG_LIB_MK1_OR_12BIT 1 +#elif BITS_IN_JSAMPLE == 12 +# define JPEG_LIB_MK1_OR_12BIT 1 +#endif + /* * We are using width_in_blocks which is supposed to be private to * libjpeg. Unfortunately, the libjpeg delivered with Cygwin has @@ -108,7 +120,7 @@ int TIFFFillTile(TIFF*, ttile_t); typedef struct jpeg_destination_mgr jpeg_destination_mgr; typedef struct jpeg_source_mgr jpeg_source_mgr; -typedef struct jpeg_error_mgr jpeg_error_mgr; +typedef struct jpeg_error_mgr jpeg_error_mgr; /* * State block for each open TIFF file using @@ -123,13 +135,13 @@ typedef struct jpeg_error_mgr jpeg_error_mgr; * so we can safely cast JPEGState* -> jpeg_xxx_struct* * and vice versa! */ -typedef struct { +typedef struct { union { struct jpeg_compress_struct c; struct jpeg_decompress_struct d; struct jpeg_common_struct comm; } cinfo; /* NB: must be first */ - int cinfo_initialized; + int cinfo_initialized; jpeg_error_mgr err; /* libjpeg error manager */ JMP_BUF exit_jmpbuf; /* for catching libjpeg failures */ @@ -144,7 +156,7 @@ typedef struct { uint16 photometric; /* copy of PhotometricInterpretation */ uint16 h_sampling; /* luminance sampling factors */ uint16 v_sampling; - tsize_t bytesperline; /* decompressed bytes per scanline */ + tmsize_t bytesperline; /* decompressed bytes per scanline */ /* pointers to intermediate buffers when processing downsampled data */ JSAMPARRAY ds_buffer[MAX_COMPONENTS]; int scancount; /* number of "scanlines" accumulated */ @@ -163,47 +175,25 @@ typedef struct { int jpegtablesmode; /* What to put in JPEGTables */ int ycbcrsampling_fetched; - uint32 recvparams; /* encoded Class 2 session params */ - char* subaddress; /* subaddress string */ - uint32 recvtime; /* time spent receiving (secs) */ - char* faxdcs; /* encoded fax parameters (DCS, Table 2/T.30) */ } JPEGState; #define JState(tif) ((JPEGState*)(tif)->tif_data) -static int JPEGDecode(TIFF*, tidata_t, tsize_t, tsample_t); -static int JPEGDecodeRaw(TIFF*, tidata_t, tsize_t, tsample_t); -static int JPEGEncode(TIFF*, tidata_t, tsize_t, tsample_t); -static int JPEGEncodeRaw(TIFF*, tidata_t, tsize_t, tsample_t); -static int JPEGInitializeLibJPEG( TIFF * tif, - int force_encode, int force_decode ); +static int JPEGDecode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s); +static int JPEGDecodeRaw(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s); +static int JPEGEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s); +static int JPEGEncodeRaw(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s); +static int JPEGInitializeLibJPEG(TIFF * tif, int decode ); +static int DecodeRowError(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s); #define FIELD_JPEGTABLES (FIELD_CODEC+0) -#define FIELD_RECVPARAMS (FIELD_CODEC+1) -#define FIELD_SUBADDRESS (FIELD_CODEC+2) -#define FIELD_RECVTIME (FIELD_CODEC+3) -#define FIELD_FAXDCS (FIELD_CODEC+4) - -static const TIFFFieldInfo jpegFieldInfo[] = { - { TIFFTAG_JPEGTABLES, -3,-3, TIFF_UNDEFINED, FIELD_JPEGTABLES, - FALSE, TRUE, "JPEGTables" }, - { TIFFTAG_JPEGQUALITY, 0, 0, TIFF_ANY, FIELD_PSEUDO, - TRUE, FALSE, "" }, - { TIFFTAG_JPEGCOLORMODE, 0, 0, TIFF_ANY, FIELD_PSEUDO, - FALSE, FALSE, "" }, - { TIFFTAG_JPEGTABLESMODE, 0, 0, TIFF_ANY, FIELD_PSEUDO, - FALSE, FALSE, "" }, - /* Specific for JPEG in faxes */ - { TIFFTAG_FAXRECVPARAMS, 1, 1, TIFF_LONG, FIELD_RECVPARAMS, - TRUE, FALSE, "FaxRecvParams" }, - { TIFFTAG_FAXSUBADDRESS, -1,-1, TIFF_ASCII, FIELD_SUBADDRESS, - TRUE, FALSE, "FaxSubAddress" }, - { TIFFTAG_FAXRECVTIME, 1, 1, TIFF_LONG, FIELD_RECVTIME, - TRUE, FALSE, "FaxRecvTime" }, - { TIFFTAG_FAXDCS, -1, -1, TIFF_ASCII, FIELD_FAXDCS, - TRUE, FALSE, "FaxDcs" }, + +static const TIFFField jpegFields[] = { + { TIFFTAG_JPEGTABLES, -3, -3, TIFF_UNDEFINED, 0, TIFF_SETGET_C32_UINT8, TIFF_SETGET_C32_UINT8, FIELD_JPEGTABLES, FALSE, TRUE, "JPEGTables", NULL }, + { TIFFTAG_JPEGQUALITY, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "", NULL }, + { TIFFTAG_JPEGCOLORMODE, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE, "", NULL }, + { TIFFTAG_JPEGTABLESMODE, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE, "", NULL } }; -#define N(a) (sizeof (a) / sizeof (a[0])) /* * libjpeg interface layer. @@ -411,6 +401,19 @@ std_empty_output_buffer(j_compress_ptr cinfo) /* the entire buffer has been filled */ tif->tif_rawcc = tif->tif_rawdatasize; + +#ifdef IPPJ_HUFF + /* + * The Intel IPP performance library does not necessarily fill up + * the whole output buffer on each pass, so only dump out the parts + * that have been filled. + * http://trac.osgeo.org/gdal/wiki/JpegIPP + */ + if ( sp->dest.free_in_buffer >= 0 ) { + tif->tif_rawcc = tif->tif_rawdatasize - sp->dest.free_in_buffer; + } +#endif + TIFFFlushData1(tif); sp->dest.next_output_byte = (JOCTET*) tif->tif_rawdata; sp->dest.free_in_buffer = (size_t) tif->tif_rawdatasize; @@ -424,9 +427,9 @@ std_term_destination(j_compress_ptr cinfo) JPEGState* sp = (JPEGState*) cinfo; TIFF* tif = sp->tif; - tif->tif_rawcp = (tidata_t) sp->dest.next_output_byte; + tif->tif_rawcp = (uint8*) sp->dest.next_output_byte; tif->tif_rawcc = - tif->tif_rawdatasize - (tsize_t) sp->dest.free_in_buffer; + tif->tif_rawdatasize - (tmsize_t) sp->dest.free_in_buffer; /* NB: libtiff does the final buffer flush */ } @@ -461,8 +464,8 @@ tables_empty_output_buffer(j_compress_ptr cinfo) void* newbuf; /* the entire buffer has been filled; enlarge it by 1000 bytes */ - newbuf = _TIFFrealloc((tdata_t) sp->jpegtables, - (tsize_t) (sp->jpegtables_length + 1000)); + newbuf = _TIFFrealloc((void*) sp->jpegtables, + (tmsize_t) (sp->jpegtables_length + 1000)); if (newbuf == NULL) ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 100); sp->dest.next_output_byte = (JOCTET*) newbuf + sp->jpegtables_length; @@ -478,7 +481,7 @@ tables_term_destination(j_compress_ptr cinfo) JPEGState* sp = (JPEGState*) cinfo; /* set tables length to number of bytes actually emitted */ - sp->jpegtables_length -= sp->dest.free_in_buffer; + sp->jpegtables_length -= (uint32) sp->dest.free_in_buffer; } static int @@ -492,7 +495,7 @@ TIFFjpeg_tables_dest(JPEGState* sp, TIFF* tif) if (sp->jpegtables) _TIFFfree(sp->jpegtables); sp->jpegtables_length = 1000; - sp->jpegtables = (void*) _TIFFmalloc((tsize_t) sp->jpegtables_length); + sp->jpegtables = (void*) _TIFFmalloc((tmsize_t) sp->jpegtables_length); if (sp->jpegtables == NULL) { sp->jpegtables_length = 0; TIFFErrorExt(sp->tif->tif_clientdata, "TIFFjpeg_tables_dest", "No space for JPEGTables"); @@ -526,11 +529,29 @@ std_fill_input_buffer(j_decompress_ptr cinfo) JPEGState* sp = (JPEGState* ) cinfo; static const JOCTET dummy_EOI[2] = { 0xFF, JPEG_EOI }; +#ifdef IPPJ_HUFF + /* + * The Intel IPP performance library does not necessarily read the whole + * input buffer in one pass, so it is possible to get here with data + * yet to read. + * + * We just return without doing anything, until the entire buffer has + * been read. + * http://trac.osgeo.org/gdal/wiki/JpegIPP + */ + if( sp->src.bytes_in_buffer > 0 ) { + return (TRUE); + } +#endif + /* - * Should never get here since entire strip/tile is - * read into memory before the decompressor is called, - * and thus was supplied by init_source. + * Normally the whole strip/tile is read and so we don't need to do + * a fill. In the case of CHUNKY_STRIP_READ_SUPPORT we might not have + * all the data, but the rawdata is refreshed between scanlines and + * we push this into the io machinery in JPEGDecode(). + * http://trac.osgeo.org/gdal/ticket/3894 */ + WARNMS(cinfo, JWRN_JPEG_EOF); /* insert a fake EOI marker */ sp->src.next_input_byte = dummy_EOI; @@ -544,7 +565,7 @@ std_skip_input_data(j_decompress_ptr cinfo, long num_bytes) JPEGState* sp = (JPEGState*) cinfo; if (num_bytes > 0) { - if (num_bytes > (long) sp->src.bytes_in_buffer) { + if ((size_t)num_bytes > sp->src.bytes_in_buffer) { /* oops, buffer overrun */ (void) std_fill_input_buffer(cinfo); } else { @@ -558,8 +579,6 @@ static void std_term_source(j_decompress_ptr cinfo) { /* No work necessary here */ - /* Or must we update tif->tif_rawcp, tif->tif_rawcc ??? */ - /* (if so, need empty tables_term_source!) */ (void) cinfo; } @@ -635,13 +654,308 @@ alloc_downsampled_buffers(TIFF* tif, jpeg_component_info* comp_info, * JPEG Decoding. */ +#ifdef CHECK_JPEG_YCBCR_SUBSAMPLING + +#define JPEG_MARKER_SOF0 0xC0 +#define JPEG_MARKER_SOF1 0xC1 +#define JPEG_MARKER_SOF3 0xC3 +#define JPEG_MARKER_DHT 0xC4 +#define JPEG_MARKER_SOI 0xD8 +#define JPEG_MARKER_SOS 0xDA +#define JPEG_MARKER_DQT 0xDB +#define JPEG_MARKER_DRI 0xDD +#define JPEG_MARKER_APP0 0xE0 +#define JPEG_MARKER_COM 0xFE +struct JPEGFixupTagsSubsamplingData +{ + TIFF* tif; + void* buffer; + uint32 buffersize; + uint8* buffercurrentbyte; + uint32 bufferbytesleft; + uint64 fileoffset; + uint64 filebytesleft; + uint8 filepositioned; +}; +static void JPEGFixupTagsSubsampling(TIFF* tif); +static int JPEGFixupTagsSubsamplingSec(struct JPEGFixupTagsSubsamplingData* data); +static int JPEGFixupTagsSubsamplingReadByte(struct JPEGFixupTagsSubsamplingData* data, uint8* result); +static int JPEGFixupTagsSubsamplingReadWord(struct JPEGFixupTagsSubsamplingData* data, uint16* result); +static void JPEGFixupTagsSubsamplingSkip(struct JPEGFixupTagsSubsamplingData* data, uint16 skiplength); + +#endif + +static int +JPEGFixupTags(TIFF* tif) +{ +#ifdef CHECK_JPEG_YCBCR_SUBSAMPLING + if ((tif->tif_dir.td_photometric==PHOTOMETRIC_YCBCR)&& + (tif->tif_dir.td_planarconfig==PLANARCONFIG_CONTIG)&& + (tif->tif_dir.td_samplesperpixel==3)) + JPEGFixupTagsSubsampling(tif); +#endif + + return(1); +} + +#ifdef CHECK_JPEG_YCBCR_SUBSAMPLING + +static void +JPEGFixupTagsSubsampling(TIFF* tif) +{ + /* + * Some JPEG-in-TIFF produces do not emit the YCBCRSUBSAMPLING values in + * the TIFF tags, but still use non-default (2,2) values within the jpeg + * data stream itself. In order for TIFF applications to work properly + * - for instance to get the strip buffer size right - it is imperative + * that the subsampling be available before we start reading the image + * data normally. This function will attempt to analyze the first strip in + * order to get the sampling values from the jpeg data stream. + * + * Note that JPEGPreDeocode() will produce a fairly loud warning when the + * discovered sampling does not match the default sampling (2,2) or whatever + * was actually in the tiff tags. + * + * See the bug in bugzilla for details: + * + * http://bugzilla.remotesensing.org/show_bug.cgi?id=168 + * + * Frank Warmerdam, July 2002 + * Joris Van Damme, May 2007 + */ + static const char module[] = "JPEGFixupTagsSubsampling"; + struct JPEGFixupTagsSubsamplingData m; + + _TIFFFillStriles( tif ); + + if( tif->tif_dir.td_stripbytecount == NULL + || tif->tif_dir.td_stripbytecount[0] == 0 ) + { + /* Do not even try to check if the first strip/tile does not + yet exist, as occurs when GDAL has created a new NULL file + for instance. */ + return; + } + + m.tif=tif; + m.buffersize=2048; + m.buffer=_TIFFmalloc(m.buffersize); + if (m.buffer==NULL) + { + TIFFWarningExt(tif->tif_clientdata,module, + "Unable to allocate memory for auto-correcting of subsampling values; auto-correcting skipped"); + return; + } + m.buffercurrentbyte=NULL; + m.bufferbytesleft=0; + m.fileoffset=tif->tif_dir.td_stripoffset[0]; + m.filepositioned=0; + m.filebytesleft=tif->tif_dir.td_stripbytecount[0]; + if (!JPEGFixupTagsSubsamplingSec(&m)) + TIFFWarningExt(tif->tif_clientdata,module, + "Unable to auto-correct subsampling values, likely corrupt JPEG compressed data in first strip/tile; auto-correcting skipped"); + _TIFFfree(m.buffer); +} + +static int +JPEGFixupTagsSubsamplingSec(struct JPEGFixupTagsSubsamplingData* data) +{ + static const char module[] = "JPEGFixupTagsSubsamplingSec"; + uint8 m; + while (1) + { + while (1) + { + if (!JPEGFixupTagsSubsamplingReadByte(data,&m)) + return(0); + if (m==255) + break; + } + while (1) + { + if (!JPEGFixupTagsSubsamplingReadByte(data,&m)) + return(0); + if (m!=255) + break; + } + switch (m) + { + case JPEG_MARKER_SOI: + /* this type of marker has no data and should be skipped */ + break; + case JPEG_MARKER_COM: + case JPEG_MARKER_APP0: + case JPEG_MARKER_APP0+1: + case JPEG_MARKER_APP0+2: + case JPEG_MARKER_APP0+3: + case JPEG_MARKER_APP0+4: + case JPEG_MARKER_APP0+5: + case JPEG_MARKER_APP0+6: + case JPEG_MARKER_APP0+7: + case JPEG_MARKER_APP0+8: + case JPEG_MARKER_APP0+9: + case JPEG_MARKER_APP0+10: + case JPEG_MARKER_APP0+11: + case JPEG_MARKER_APP0+12: + case JPEG_MARKER_APP0+13: + case JPEG_MARKER_APP0+14: + case JPEG_MARKER_APP0+15: + case JPEG_MARKER_DQT: + case JPEG_MARKER_SOS: + case JPEG_MARKER_DHT: + case JPEG_MARKER_DRI: + /* this type of marker has data, but it has no use to us and should be skipped */ + { + uint16 n; + if (!JPEGFixupTagsSubsamplingReadWord(data,&n)) + return(0); + if (n<2) + return(0); + n-=2; + if (n>0) + JPEGFixupTagsSubsamplingSkip(data,n); + } + break; + case JPEG_MARKER_SOF0: + case JPEG_MARKER_SOF1: + /* this marker contains the subsampling factors we're scanning for */ + { + uint16 n; + uint16 o; + uint8 p; + uint8 ph,pv; + if (!JPEGFixupTagsSubsamplingReadWord(data,&n)) + return(0); + if (n!=8+data->tif->tif_dir.td_samplesperpixel*3) + return(0); + JPEGFixupTagsSubsamplingSkip(data,7); + if (!JPEGFixupTagsSubsamplingReadByte(data,&p)) + return(0); + ph=(p>>4); + pv=(p&15); + JPEGFixupTagsSubsamplingSkip(data,1); + for (o=1; o<data->tif->tif_dir.td_samplesperpixel; o++) + { + JPEGFixupTagsSubsamplingSkip(data,1); + if (!JPEGFixupTagsSubsamplingReadByte(data,&p)) + return(0); + if (p!=0x11) + { + TIFFWarningExt(data->tif->tif_clientdata,module, + "Subsampling values inside JPEG compressed data have no TIFF equivalent, auto-correction of TIFF subsampling values failed"); + return(1); + } + JPEGFixupTagsSubsamplingSkip(data,1); + } + if (((ph!=1)&&(ph!=2)&&(ph!=4))||((pv!=1)&&(pv!=2)&&(pv!=4))) + { + TIFFWarningExt(data->tif->tif_clientdata,module, + "Subsampling values inside JPEG compressed data have no TIFF equivalent, auto-correction of TIFF subsampling values failed"); + return(1); + } + if ((ph!=data->tif->tif_dir.td_ycbcrsubsampling[0])||(pv!=data->tif->tif_dir.td_ycbcrsubsampling[1])) + { + TIFFWarningExt(data->tif->tif_clientdata,module, + "Auto-corrected former TIFF subsampling values [%d,%d] to match subsampling values inside JPEG compressed data [%d,%d]", + (int)data->tif->tif_dir.td_ycbcrsubsampling[0], + (int)data->tif->tif_dir.td_ycbcrsubsampling[1], + (int)ph,(int)pv); + data->tif->tif_dir.td_ycbcrsubsampling[0]=ph; + data->tif->tif_dir.td_ycbcrsubsampling[1]=pv; + } + } + return(1); + default: + return(0); + } + } +} + +static int +JPEGFixupTagsSubsamplingReadByte(struct JPEGFixupTagsSubsamplingData* data, uint8* result) +{ + if (data->bufferbytesleft==0) + { + uint32 m; + if (data->filebytesleft==0) + return(0); + if (!data->filepositioned) + { + TIFFSeekFile(data->tif,data->fileoffset,SEEK_SET); + data->filepositioned=1; + } + m=data->buffersize; + if ((uint64)m>data->filebytesleft) + m=(uint32)data->filebytesleft; + assert(m<0x80000000UL); + if (TIFFReadFile(data->tif,data->buffer,(tmsize_t)m)!=(tmsize_t)m) + return(0); + data->buffercurrentbyte=data->buffer; + data->bufferbytesleft=m; + data->fileoffset+=m; + data->filebytesleft-=m; + } + *result=*data->buffercurrentbyte; + data->buffercurrentbyte++; + data->bufferbytesleft--; + return(1); +} + +static int +JPEGFixupTagsSubsamplingReadWord(struct JPEGFixupTagsSubsamplingData* data, uint16* result) +{ + uint8 ma; + uint8 mb; + if (!JPEGFixupTagsSubsamplingReadByte(data,&ma)) + return(0); + if (!JPEGFixupTagsSubsamplingReadByte(data,&mb)) + return(0); + *result=(ma<<8)|mb; + return(1); +} + +static void +JPEGFixupTagsSubsamplingSkip(struct JPEGFixupTagsSubsamplingData* data, uint16 skiplength) +{ + if ((uint32)skiplength<=data->bufferbytesleft) + { + data->buffercurrentbyte+=skiplength; + data->bufferbytesleft-=skiplength; + } + else + { + uint16 m; + m=skiplength-data->bufferbytesleft; + if (m<=data->filebytesleft) + { + data->bufferbytesleft=0; + data->fileoffset+=m; + data->filebytesleft-=m; + data->filepositioned=0; + } + else + { + data->bufferbytesleft=0; + data->filebytesleft=0; + } + } +} + +#endif + + static int JPEGSetupDecode(TIFF* tif) { JPEGState* sp = JState(tif); TIFFDirectory *td = &tif->tif_dir; - JPEGInitializeLibJPEG( tif, 0, 1 ); +#if defined(JPEG_DUAL_MODE_8_12) && !defined(TIFFInitJPEG) + if( tif->tif_dir.td_bitspersample == 12 ) + return TIFFReInitJPEG_12( tif, COMPRESSION_JPEG, 0 ); +#endif + + JPEGInitializeLibJPEG( tif, TRUE ); assert(sp != NULL); assert(sp->cinfo.comm.is_decompressor); @@ -679,7 +993,7 @@ JPEGSetupDecode(TIFF* tif) * Set up for decoding a strip or tile. */ static int -JPEGPreDecode(TIFF* tif, tsample_t s) +JPEGPreDecode(TIFF* tif, uint16 s) { JPEGState *sp = JState(tif); TIFFDirectory *td = &tif->tif_dir; @@ -689,6 +1003,12 @@ JPEGPreDecode(TIFF* tif, tsample_t s) int ci; assert(sp != NULL); + + if (sp->cinfo.comm.is_decompressor == 0) + { + tif->tif_setupdecode( tif ); + } + assert(sp->cinfo.comm.is_decompressor); /* * Reset decoder state from any previous strip/tile, @@ -699,8 +1019,13 @@ JPEGPreDecode(TIFF* tif, tsample_t s) /* * Read the header for this strip/tile. */ + if (TIFFjpeg_read_header(sp, TRUE) != JPEG_HEADER_OK) return (0); + + tif->tif_rawcp = (uint8*) sp->src.next_input_byte; + tif->tif_rawcc = sp->src.bytes_in_buffer; + /* * Check image parameters and set decompression parameters. */ @@ -713,15 +1038,15 @@ JPEGPreDecode(TIFF* tif, tsample_t s) } else { if (segment_height > td->td_rowsperstrip) segment_height = td->td_rowsperstrip; - sp->bytesperline = TIFFOldScanlineSize(tif); + sp->bytesperline = TIFFScanlineSize(tif); } if (td->td_planarconfig == PLANARCONFIG_SEPARATE && s > 0) { /* * For PC 2, scale down the expected strip/tile size * to match a downsampled component */ - segment_width = TIFFhowmany(segment_width, sp->h_sampling); - segment_height = TIFFhowmany(segment_height, sp->v_sampling); + segment_width = TIFFhowmany_32(segment_width, sp->h_sampling); + segment_height = TIFFhowmany_32(segment_height, sp->v_sampling); } if (sp->cinfo.d.image_width < segment_width || sp->cinfo.d.image_height < segment_height) { @@ -755,65 +1080,28 @@ JPEGPreDecode(TIFF* tif, tsample_t s) } #ifdef JPEG_LIB_MK1 if (12 != td->td_bitspersample && 8 != td->td_bitspersample) { - TIFFErrorExt(tif->tif_clientdata, module, "Improper JPEG data precision"); - return (0); + TIFFErrorExt(tif->tif_clientdata, module, "Improper JPEG data precision"); + return (0); } - sp->cinfo.d.data_precision = td->td_bitspersample; - sp->cinfo.d.bits_in_jsample = td->td_bitspersample; + sp->cinfo.d.data_precision = td->td_bitspersample; + sp->cinfo.d.bits_in_jsample = td->td_bitspersample; #else if (sp->cinfo.d.data_precision != td->td_bitspersample) { - TIFFErrorExt(tif->tif_clientdata, module, "Improper JPEG data precision"); - return (0); + TIFFErrorExt(tif->tif_clientdata, module, "Improper JPEG data precision"); + return (0); } #endif if (td->td_planarconfig == PLANARCONFIG_CONTIG) { /* Component 0 should have expected sampling factors */ if (sp->cinfo.d.comp_info[0].h_samp_factor != sp->h_sampling || sp->cinfo.d.comp_info[0].v_samp_factor != sp->v_sampling) { - TIFFWarningExt(tif->tif_clientdata, module, - "Improper JPEG sampling factors %d,%d\n" - "Apparently should be %d,%d.", - sp->cinfo.d.comp_info[0].h_samp_factor, - sp->cinfo.d.comp_info[0].v_samp_factor, - sp->h_sampling, sp->v_sampling); - - /* - * There are potential security issues here - * for decoders that have already allocated - * buffers based on the expected sampling - * factors. Lets check the sampling factors - * dont exceed what we were expecting. - */ - if (sp->cinfo.d.comp_info[0].h_samp_factor - > sp->h_sampling - || sp->cinfo.d.comp_info[0].v_samp_factor - > sp->v_sampling) { - TIFFErrorExt(tif->tif_clientdata, - module, - "Cannot honour JPEG sampling factors" - " that exceed those specified."); - return (0); - } - - /* - * XXX: Files written by the Intergraph software - * has different sampling factors stored in the - * TIFF tags and in the JPEG structures. We will - * try to deduce Intergraph files by the presense - * of the tag 33918. - */ - if (!_TIFFFindFieldInfo(tif, 33918, TIFF_ANY)) { - TIFFWarningExt(tif->tif_clientdata, module, - "Decompressor will try reading with " - "sampling %d,%d.", - sp->cinfo.d.comp_info[0].h_samp_factor, - sp->cinfo.d.comp_info[0].v_samp_factor); - - sp->h_sampling = (uint16) - sp->cinfo.d.comp_info[0].h_samp_factor; - sp->v_sampling = (uint16) - sp->cinfo.d.comp_info[0].v_samp_factor; - } + TIFFErrorExt(tif->tif_clientdata, module, + "Improper JPEG sampling factors %d,%d\n" + "Apparently should be %d,%d.", + sp->cinfo.d.comp_info[0].h_samp_factor, + sp->cinfo.d.comp_info[0].v_samp_factor, + sp->h_sampling, sp->v_sampling); + return (0); } /* Rest should have sampling factors 1,1 */ for (ci = 1; ci < sp->cinfo.d.num_components; ci++) { @@ -835,11 +1123,11 @@ JPEGPreDecode(TIFF* tif, tsample_t s) if (td->td_planarconfig == PLANARCONFIG_CONTIG && sp->photometric == PHOTOMETRIC_YCBCR && sp->jpegcolormode == JPEGCOLORMODE_RGB) { - /* Convert YCbCr to RGB */ + /* Convert YCbCr to RGB */ sp->cinfo.d.jpeg_color_space = JCS_YCbCr; sp->cinfo.d.out_color_space = JCS_RGB; } else { - /* Suppress colorspace handling */ + /* Suppress colorspace handling */ sp->cinfo.d.jpeg_color_space = JCS_UNKNOWN; sp->cinfo.d.out_color_space = JCS_UNKNOWN; if (td->td_planarconfig == PLANARCONFIG_CONTIG && @@ -850,7 +1138,10 @@ JPEGPreDecode(TIFF* tif, tsample_t s) if (downsampled_output) { /* Need to use raw-data interface to libjpeg */ sp->cinfo.d.raw_data_out = TRUE; - tif->tif_decoderow = JPEGDecodeRaw; +#if JPEG_LIB_VERSION >= 70 + sp->cinfo.d.do_fancy_upsampling = FALSE; +#endif /* JPEG_LIB_VERSION >= 70 */ + tif->tif_decoderow = DecodeRowError; tif->tif_decodestrip = JPEGDecodeRaw; tif->tif_decodetile = JPEGDecodeRaw; } else { @@ -858,7 +1149,7 @@ JPEGPreDecode(TIFF* tif, tsample_t s) sp->cinfo.d.raw_data_out = FALSE; tif->tif_decoderow = JPEGDecode; tif->tif_decodestrip = JPEGDecode; - tif->tif_decodetile = JPEGDecode; + tif->tif_decodetile = JPEGDecode; } /* Start JPEG decompressor */ if (!TIFFjpeg_start_decompress(sp)) @@ -878,103 +1169,130 @@ JPEGPreDecode(TIFF* tif, tsample_t s) * "Standard" case: returned data is not downsampled. */ /*ARGSUSED*/ static int -JPEGDecode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) +JPEGDecode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s) { - JPEGState *sp = JState(tif); - tsize_t nrows; - (void) 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; - nrows = cc / sp->bytesperline; - if (cc % sp->bytesperline) + if( sp->bytesperline == 0 ) + return 0; + + nrows = cc / sp->bytesperline; + if (cc % sp->bytesperline) TIFFWarningExt(tif->tif_clientdata, tif->tif_name, "fractional scanline not read"); - if( nrows > (int) sp->cinfo.d.image_height ) - nrows = sp->cinfo.d.image_height; + 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) - { - JSAMPROW line_work_buf = NULL; + /* data is expected to be read in multiples of a scanline */ + if (nrows) + { + JSAMPROW line_work_buf = NULL; - /* - ** For 6B, only use temporary buffer for 12 bit imagery. - ** For Mk1 always use it. - */ -#if !defined(JPEG_LIB_MK1) - if( sp->cinfo.d.data_precision == 12 ) + /* + * For 6B, only use temporary buffer for 12 bit imagery. + * For Mk1 always use it. + */ +#if !defined(JPEG_LIB_MK1) + if( sp->cinfo.d.data_precision == 12 ) #endif - { - line_work_buf = (JSAMPROW) - _TIFFmalloc(sizeof(short) * sp->cinfo.d.output_width - * sp->cinfo.d.num_components ); - } + { + line_work_buf = (JSAMPROW) + _TIFFmalloc(sizeof(short) * sp->cinfo.d.output_width + * sp->cinfo.d.num_components ); + } - do { - if( line_work_buf != NULL ) - { - /* - ** In the MK1 case, we aways 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; - JSAMPLE *in_ptr = line_work_buf + iPair * 2; - - out_ptr[0] = (in_ptr[0] & 0xff0) >> 4; - out_ptr[1] = ((in_ptr[0] & 0xf) << 4) - | ((in_ptr[1] & 0xf00) >> 8); - out_ptr[2] = ((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; - } - } - } - else - { - /* - ** In the libjpeg6b 8bit case. We read directly into the - ** TIFF buffer. - */ - JSAMPROW bufptr = (JSAMPROW)buf; - - if (TIFFjpeg_read_scanlines(sp, &bufptr, 1) != 1) - return (0); - } + do { + if( line_work_buf != NULL ) + { + /* + * In the MK1 case, we aways 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); - ++tif->tif_row; - buf += sp->bytesperline; - cc -= sp->bytesperline; - } while (--nrows > 0); + if( sp->cinfo.d.data_precision == 12 ) + { + int value_pairs = (sp->cinfo.d.output_width + * sp->cinfo.d.num_components) / 2; + int iPair; - if( line_work_buf != NULL ) - _TIFFfree( line_work_buf ); - } + for( iPair = 0; iPair < value_pairs; iPair++ ) + { + unsigned char *out_ptr = + ((unsigned char *) buf) + iPair * 3; + JSAMPLE *in_ptr = line_work_buf + iPair * 2; + + out_ptr[0] = (in_ptr[0] & 0xff0) >> 4; + out_ptr[1] = ((in_ptr[0] & 0xf) << 4) + | ((in_ptr[1] & 0xf00) >> 8); + out_ptr[2] = ((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; + } + } + } + else + { + /* + * In the libjpeg6b 8bit case. We read directly into the + * TIFF buffer. + */ + JSAMPROW bufptr = (JSAMPROW)buf; + + if (TIFFjpeg_read_scanlines(sp, &bufptr, 1) != 1) + return (0); + } + + ++tif->tif_row; + buf += sp->bytesperline; + cc -= sp->bytesperline; + } while (--nrows > 0); + + if( line_work_buf != NULL ) + _TIFFfree( line_work_buf ); + } + + /* Update information on consumed data */ + tif->tif_rawcp = (uint8*) 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); +} + +/*ARGSUSED*/ static int +DecodeRowError(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s) + +{ + (void) buf; + (void) cc; + (void) s; - /* 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); + TIFFErrorExt(tif->tif_clientdata, "TIFFReadScanline", + "scanline oriented access is not supported for downsampled JPEG compressed images, consider enabling TIFF_JPEGCOLORMODE as JPEGCOLORMODE_RGB." ); + return 0; } /* @@ -982,28 +1300,40 @@ JPEGDecode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) * Returned data is downsampled per sampling factors. */ /*ARGSUSED*/ static int -JPEGDecodeRaw(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) +JPEGDecodeRaw(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s) { JPEGState *sp = JState(tif); - tsize_t nrows; + tmsize_t nrows; (void) s; /* data is expected to be read in multiples of a scanline */ if ( (nrows = sp->cinfo.d.image_height) ) { + /* Cb,Cr both have sampling factors 1, so this is correct */ JDIMENSION clumps_per_line = sp->cinfo.d.comp_info[1].downsampled_width; int samples_per_clump = sp->samplesperclump; -#ifdef JPEG_LIB_MK1 +#if defined(JPEG_LIB_MK1_OR_12BIT) unsigned short* tmpbuf = _TIFFmalloc(sizeof(unsigned short) * - sp->cinfo.d.output_width * - sp->cinfo.d.num_components); + sp->cinfo.d.output_width * + sp->cinfo.d.num_components); + if(tmpbuf==NULL) { + TIFFErrorExt(tif->tif_clientdata, "JPEGDecodeRaw", + "Out of memory"); + return 0; + } #endif do { jpeg_component_info *compptr; int ci, clumpoffset; + if( cc < sp->bytesperline ) { + TIFFErrorExt(tif->tif_clientdata, "JPEGDecodeRaw", + "application buffer not large enough for all data."); + return 0; + } + /* Reload downsampled-data buffer if needed */ if (sp->scancount >= DCTSIZE) { int n = sp->cinfo.d.max_v_samp_factor * DCTSIZE; @@ -1017,20 +1347,25 @@ JPEGDecodeRaw(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) */ clumpoffset = 0; /* first sample in clump */ for (ci = 0, compptr = sp->cinfo.d.comp_info; - ci < sp->cinfo.d.num_components; - ci++, compptr++) { + ci < sp->cinfo.d.num_components; + ci++, compptr++) { int hsamp = compptr->h_samp_factor; int vsamp = compptr->v_samp_factor; int ypos; for (ypos = 0; ypos < vsamp; ypos++) { JSAMPLE *inptr = sp->ds_buffer[ci][sp->scancount*vsamp + ypos]; -#ifdef JPEG_LIB_MK1 + JDIMENSION nclump; +#if defined(JPEG_LIB_MK1_OR_12BIT) JSAMPLE *outptr = (JSAMPLE*)tmpbuf + clumpoffset; #else JSAMPLE *outptr = (JSAMPLE*)buf + clumpoffset; + if (cc < (tmsize_t) (clumpoffset + samples_per_clump*(clumps_per_line-1) + hsamp)) { + TIFFErrorExt(tif->tif_clientdata, "JPEGDecodeRaw", + "application buffer not large enough for all data, possible subsampling issue"); + return 0; + } #endif - JDIMENSION nclump; if (hsamp == 1) { /* fast path for at least Cb and Cr */ @@ -1041,7 +1376,7 @@ JPEGDecodeRaw(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) } else { int xpos; - /* general case */ + /* general case */ for (nclump = clumps_per_line; nclump-- > 0; ) { for (xpos = 0; xpos < hsamp; xpos++) outptr[xpos] = *inptr++; @@ -1052,7 +1387,7 @@ JPEGDecodeRaw(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) } } -#ifdef JPEG_LIB_MK1 +#if defined(JPEG_LIB_MK1_OR_12BIT) { if (sp->cinfo.d.data_precision == 8) { @@ -1064,17 +1399,17 @@ JPEGDecodeRaw(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) } } else - { // 12-bit + { /* 12-bit */ int value_pairs = (sp->cinfo.d.output_width - * sp->cinfo.d.num_components) / 2; + * sp->cinfo.d.num_components) / 2; int iPair; for( iPair = 0; iPair < value_pairs; iPair++ ) { unsigned char *out_ptr = ((unsigned char *) buf) + iPair * 3; - JSAMPLE *in_ptr = tmpbuf + iPair * 2; + JSAMPLE *in_ptr = (JSAMPLE *) (tmpbuf + iPair * 2); out_ptr[0] = (in_ptr[0] & 0xff0) >> 4; out_ptr[1] = ((in_ptr[0] & 0xf) << 4) - | ((in_ptr[1] & 0xf00) >> 8); + | ((in_ptr[1] & 0xf00) >> 8); out_ptr[2] = ((in_ptr[1] & 0xff) >> 0); } } @@ -1083,14 +1418,14 @@ JPEGDecodeRaw(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) sp->scancount ++; tif->tif_row += sp->v_sampling; - /* increment/decrement of buf and cc is still incorrect, but should not matter - * TODO: resolve this */ + buf += sp->bytesperline; cc -= sp->bytesperline; + nrows -= sp->v_sampling; } while (nrows > 0); -#ifdef JPEG_LIB_MK1 +#if defined(JPEG_LIB_MK1_OR_12BIT) _TIFFfree(tmpbuf); #endif @@ -1098,7 +1433,7 @@ JPEGDecodeRaw(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) /* Close down the decompressor if done. */ return sp->cinfo.d.output_scanline < sp->cinfo.d.output_height - || TIFFjpeg_finish_decompress(sp); + || TIFFjpeg_finish_decompress(sp); } @@ -1131,8 +1466,6 @@ prepare_JPEGTables(TIFF* tif) { JPEGState* sp = JState(tif); - JPEGInitializeLibJPEG( tif, 0, 0 ); - /* Initialize quant tables for current quality setting */ if (!TIFFjpeg_set_quality(sp, sp->jpegquality, FALSE)) return (0); @@ -1167,7 +1500,12 @@ JPEGSetupEncode(TIFF* tif) TIFFDirectory *td = &tif->tif_dir; static const char module[] = "JPEGSetupEncode"; - JPEGInitializeLibJPEG( tif, 1, 0 ); +#if defined(JPEG_DUAL_MODE_8_12) && !defined(TIFFInitJPEG) + if( tif->tif_dir.td_bitspersample == 12 ) + return TIFFReInitJPEG_12( tif, COMPRESSION_JPEG, 1 ); +#endif + + JPEGInitializeLibJPEG( tif, FALSE ); assert(sp != NULL); assert(!sp->cinfo.comm.is_decompressor); @@ -1269,12 +1607,16 @@ JPEGSetupEncode(TIFF* tif) /* Create a JPEGTables field if appropriate */ if (sp->jpegtablesmode & (JPEGTABLESMODE_QUANT|JPEGTABLESMODE_HUFF)) { - if (!prepare_JPEGTables(tif)) - return (0); - /* Mark the field present */ - /* Can't use TIFFSetField since BEENWRITING is already set! */ - TIFFSetFieldBit(tif, FIELD_JPEGTABLES); - tif->tif_flags |= TIFF_DIRTYDIRECT; + if( sp->jpegtables == NULL + || memcmp(sp->jpegtables,"\0\0\0\0\0\0\0\0\0",8) == 0 ) + { + if (!prepare_JPEGTables(tif)) + return (0); + /* Mark the field present */ + /* Can't use TIFFSetField since BEENWRITING is already set! */ + tif->tif_flags |= TIFF_DIRTYDIRECT; + TIFFSetFieldBit(tif, FIELD_JPEGTABLES); + } } else { /* We do not support application-supplied JPEGTables, */ /* so mark the field not present */ @@ -1291,7 +1633,7 @@ JPEGSetupEncode(TIFF* tif) * Set encoding state at the start of a strip or tile. */ static int -JPEGPreEncode(TIFF* tif, tsample_t s) +JPEGPreEncode(TIFF* tif, uint16 s) { JPEGState *sp = JState(tif); TIFFDirectory *td = &tif->tif_dir; @@ -1300,6 +1642,12 @@ JPEGPreEncode(TIFF* tif, tsample_t s) int downsampled_input; assert(sp != NULL); + + if (sp->cinfo.comm.is_decompressor == 1) + { + tif->tif_setupencode( tif ); + } + assert(!sp->cinfo.comm.is_decompressor); /* * Set encoding parameters for this strip/tile. @@ -1313,14 +1661,14 @@ JPEGPreEncode(TIFF* tif, tsample_t s) segment_height = td->td_imagelength - tif->tif_row; if (segment_height > td->td_rowsperstrip) segment_height = td->td_rowsperstrip; - sp->bytesperline = TIFFOldScanlineSize(tif); + sp->bytesperline = TIFFScanlineSize(tif); } if (td->td_planarconfig == PLANARCONFIG_SEPARATE && s > 0) { /* for PC 2, scale down the strip/tile size * to match a downsampled component */ - segment_width = TIFFhowmany(segment_width, sp->h_sampling); - segment_height = TIFFhowmany(segment_height, sp->v_sampling); + segment_width = TIFFhowmany_32(segment_width, sp->h_sampling); + segment_height = TIFFhowmany_32(segment_height, sp->v_sampling); } if (segment_width > 65535 || segment_height > 65535) { TIFFErrorExt(tif->tif_clientdata, module, "Strip/tile too large for JPEG"); @@ -1348,8 +1696,15 @@ JPEGPreEncode(TIFF* tif, tsample_t s) sp->cinfo.c.comp_info[0].h_samp_factor = sp->h_sampling; sp->cinfo.c.comp_info[0].v_samp_factor = sp->v_sampling; } else { - sp->cinfo.c.in_color_space = JCS_UNKNOWN; - if (!TIFFjpeg_set_colorspace(sp, JCS_UNKNOWN)) + if ((td->td_photometric == PHOTOMETRIC_MINISWHITE || td->td_photometric == PHOTOMETRIC_MINISBLACK) && td->td_samplesperpixel == 1) + sp->cinfo.c.in_color_space = JCS_GRAYSCALE; + else if (td->td_photometric == PHOTOMETRIC_RGB && td->td_samplesperpixel == 3) + sp->cinfo.c.in_color_space = JCS_RGB; + else if (td->td_photometric == PHOTOMETRIC_SEPARATED && td->td_samplesperpixel == 4) + sp->cinfo.c.in_color_space = JCS_CMYK; + else + sp->cinfo.c.in_color_space = JCS_UNKNOWN; + if (!TIFFjpeg_set_colorspace(sp, sp->cinfo.c.in_color_space)) return (0); /* jpeg_set_colorspace set all sampling factors to 1 */ } @@ -1370,9 +1725,9 @@ JPEGPreEncode(TIFF* tif, tsample_t s) sp->cinfo.c.write_JFIF_header = FALSE; sp->cinfo.c.write_Adobe_marker = FALSE; /* set up table handling correctly */ + if (!TIFFjpeg_set_quality(sp, sp->jpegquality, FALSE)) + return (0); if (! (sp->jpegtablesmode & JPEGTABLESMODE_QUANT)) { - if (!TIFFjpeg_set_quality(sp, sp->jpegquality, FALSE)) - return (0); unsuppress_quant_table(sp, 0); unsuppress_quant_table(sp, 1); } @@ -1412,31 +1767,69 @@ JPEGPreEncode(TIFF* tif, tsample_t s) * "Standard" case: incoming data is not downsampled. */ static int -JPEGEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) +JPEGEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s) { JPEGState *sp = JState(tif); - tsize_t nrows; + tmsize_t nrows; JSAMPROW bufptr[1]; + short *line16 = NULL; + int line16_count = 0; (void) s; assert(sp != NULL); /* data is expected to be supplied in multiples of a scanline */ nrows = cc / sp->bytesperline; if (cc % sp->bytesperline) - TIFFWarningExt(tif->tif_clientdata, tif->tif_name, "fractional scanline discarded"); + TIFFWarningExt(tif->tif_clientdata, tif->tif_name, + "fractional scanline discarded"); /* The last strip will be limited to image size */ if( !isTiled(tif) && tif->tif_row+nrows > tif->tif_dir.td_imagelength ) nrows = tif->tif_dir.td_imagelength - tif->tif_row; + if( sp->cinfo.c.data_precision == 12 ) + { + line16_count = (sp->bytesperline * 2) / 3; + line16 = (short *) _TIFFmalloc(sizeof(short) * line16_count); + // FIXME: undiagnosed malloc failure + } + while (nrows-- > 0) { + + if( sp->cinfo.c.data_precision == 12 ) + { + + int value_pairs = line16_count / 2; + int iPair; + + bufptr[0] = (JSAMPROW) line16; + + for( iPair = 0; iPair < value_pairs; iPair++ ) + { + unsigned char *in_ptr = + ((unsigned char *) buf) + iPair * 3; + JSAMPLE *out_ptr = (JSAMPLE *) (line16 + iPair * 2); + + out_ptr[0] = (in_ptr[0] << 4) | ((in_ptr[1] & 0xf0) >> 4); + out_ptr[1] = ((in_ptr[1] & 0x0f) << 8) | in_ptr[2]; + } + } + else + { bufptr[0] = (JSAMPROW) buf; - if (TIFFjpeg_write_scanlines(sp, bufptr, 1) != 1) - return (0); - if (nrows > 0) - tif->tif_row++; - buf += sp->bytesperline; + } + if (TIFFjpeg_write_scanlines(sp, bufptr, 1) != 1) + return (0); + if (nrows > 0) + tif->tif_row++; + buf += sp->bytesperline; } + + if( sp->cinfo.c.data_precision == 12 ) + { + _TIFFfree( line16 ); + } + return (1); } @@ -1445,17 +1838,17 @@ JPEGEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) * Incoming data is expected to be downsampled per sampling factors. */ static int -JPEGEncodeRaw(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) +JPEGEncodeRaw(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s) { JPEGState *sp = JState(tif); JSAMPLE* inptr; JSAMPLE* outptr; - tsize_t nrows; + tmsize_t nrows; JDIMENSION clumps_per_line, nclump; int clumpoffset, ci, xpos, ypos; jpeg_component_info* compptr; int samples_per_clump = sp->samplesperclump; - tsize_t bytesperclumpline; + tmsize_t bytesperclumpline; (void) s; assert(sp != NULL); @@ -1519,7 +1912,7 @@ JPEGEncodeRaw(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) sp->scancount = 0; } tif->tif_row += sp->v_sampling; - buf += sp->bytesperline; + buf += bytesperclumpline; nrows -= sp->v_sampling; } return (1); @@ -1545,12 +1938,12 @@ JPEGPostEncode(TIFF* tif) ci < sp->cinfo.c.num_components; ci++, compptr++) { int vsamp = compptr->v_samp_factor; - tsize_t row_width = compptr->width_in_blocks * DCTSIZE + tmsize_t row_width = compptr->width_in_blocks * DCTSIZE * sizeof(JSAMPLE); for (ypos = sp->scancount * vsamp; ypos < DCTSIZE * vsamp; ypos++) { - _TIFFmemcpy((tdata_t)sp->ds_buffer[ci][ypos], - (tdata_t)sp->ds_buffer[ci][ypos-1], + _TIFFmemcpy((void*)sp->ds_buffer[ci][ypos], + (void*)sp->ds_buffer[ci][ypos-1], row_width); } @@ -1574,10 +1967,12 @@ JPEGCleanup(TIFF* tif) tif->tif_tagmethods.vsetfield = sp->vsetparent; tif->tif_tagmethods.printdir = sp->printdir; - if( sp->cinfo_initialized ) - TIFFjpeg_destroy(sp); /* release libjpeg resources */ - if (sp->jpegtables) /* tag value */ - _TIFFfree(sp->jpegtables); + if( sp != NULL ) { + if( sp->cinfo_initialized ) + TIFFjpeg_destroy(sp); /* release libjpeg resources */ + if (sp->jpegtables) /* tag value */ + _TIFFfree(sp->jpegtables); + } _TIFFfree(tif->tif_data); /* release local state */ tif->tif_data = NULL; @@ -1613,21 +2008,24 @@ JPEGResetUpsampled( TIFF* tif ) * Must recalculate cached tile size in case sampling state changed. * Should we really be doing this now if image size isn't set? */ - tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tsize_t) -1; + if( tif->tif_tilesize > 0 ) + tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tmsize_t)(-1); + if( tif->tif_scanlinesize > 0 ) + tif->tif_scanlinesize = TIFFScanlineSize(tif); } static int -JPEGVSetField(TIFF* tif, ttag_t tag, va_list ap) +JPEGVSetField(TIFF* tif, uint32 tag, va_list ap) { JPEGState* sp = JState(tif); - const TIFFFieldInfo* fip; + const TIFFField* fip; uint32 v32; assert(sp != NULL); switch (tag) { case TIFFTAG_JPEGTABLES: - v32 = va_arg(ap, uint32); + v32 = (uint32) va_arg(ap, uint32); if (v32 == 0) { /* XXX */ return (0); @@ -1638,43 +2036,31 @@ JPEGVSetField(TIFF* tif, ttag_t tag, va_list ap) TIFFSetFieldBit(tif, FIELD_JPEGTABLES); break; case TIFFTAG_JPEGQUALITY: - sp->jpegquality = va_arg(ap, int); + sp->jpegquality = (int) va_arg(ap, int); return (1); /* pseudo tag */ case TIFFTAG_JPEGCOLORMODE: - sp->jpegcolormode = va_arg(ap, int); - JPEGResetUpsampled( tif ); + sp->jpegcolormode = (int) va_arg(ap, int); + JPEGResetUpsampled( tif ); return (1); /* pseudo tag */ case TIFFTAG_PHOTOMETRIC: - { - int ret_value = (*sp->vsetparent)(tif, tag, ap); - JPEGResetUpsampled( tif ); - return ret_value; - } + { + int ret_value = (*sp->vsetparent)(tif, tag, ap); + JPEGResetUpsampled( tif ); + return ret_value; + } case TIFFTAG_JPEGTABLESMODE: - sp->jpegtablesmode = va_arg(ap, int); + sp->jpegtablesmode = (int) va_arg(ap, int); return (1); /* pseudo tag */ case TIFFTAG_YCBCRSUBSAMPLING: - /* mark the fact that we have a real ycbcrsubsampling! */ + /* mark the fact that we have a real ycbcrsubsampling! */ sp->ycbcrsampling_fetched = 1; - /* should we be recomputing upsampling info here? */ + /* should we be recomputing upsampling info here? */ return (*sp->vsetparent)(tif, tag, ap); - case TIFFTAG_FAXRECVPARAMS: - sp->recvparams = va_arg(ap, uint32); - break; - case TIFFTAG_FAXSUBADDRESS: - _TIFFsetString(&sp->subaddress, va_arg(ap, char*)); - break; - case TIFFTAG_FAXRECVTIME: - sp->recvtime = va_arg(ap, uint32); - break; - case TIFFTAG_FAXDCS: - _TIFFsetString(&sp->faxdcs, va_arg(ap, char*)); - break; default: return (*sp->vsetparent)(tif, tag, ap); } - if ((fip = _TIFFFieldWithTag(tif, tag))) { + if ((fip = TIFFFieldWithTag(tif, tag))) { TIFFSetFieldBit(tif, fip->field_bit); } else { return (0); @@ -1684,75 +2070,8 @@ JPEGVSetField(TIFF* tif, ttag_t tag, va_list ap) return (1); } -/* - * Some JPEG-in-TIFF produces do not emit the YCBCRSUBSAMPLING values in - * the TIFF tags, but still use non-default (2,2) values within the jpeg - * data stream itself. In order for TIFF applications to work properly - * - for instance to get the strip buffer size right - it is imperative - * that the subsampling be available before we start reading the image - * data normally. This function will attempt to load the first strip in - * order to get the sampling values from the jpeg data stream. Various - * hacks are various places are done to ensure this function gets called - * before the td_ycbcrsubsampling values are used from the directory structure, - * including calling TIFFGetField() for the YCBCRSUBSAMPLING field from - * TIFFStripSize(), and the printing code in tif_print.c. - * - * Note that JPEGPreDeocode() will produce a fairly loud warning when the - * discovered sampling does not match the default sampling (2,2) or whatever - * was actually in the tiff tags. - * - * Problems: - * o This code will cause one whole strip/tile of compressed data to be - * loaded just to get the tags right, even if the imagery is never read. - * It would be more efficient to just load a bit of the header, and - * initialize things from that. - * - * See the bug in bugzilla for details: - * - * http://bugzilla.remotesensing.org/show_bug.cgi?id=168 - * - * Frank Warmerdam, July 2002 - */ - -static void -JPEGFixupTestSubsampling( TIFF * tif ) -{ -#ifdef CHECK_JPEG_YCBCR_SUBSAMPLING - JPEGState *sp = JState(tif); - TIFFDirectory *td = &tif->tif_dir; - - JPEGInitializeLibJPEG( tif, 0, 0 ); - - /* - * Some JPEG-in-TIFF files don't provide the ycbcrsampling tags, - * and use a sampling schema other than the default 2,2. To handle - * this we actually have to scan the header of a strip or tile of - * jpeg data to get the sampling. - */ - if( !sp->cinfo.comm.is_decompressor - || sp->ycbcrsampling_fetched - || td->td_photometric != PHOTOMETRIC_YCBCR ) - return; - - sp->ycbcrsampling_fetched = 1; - if( TIFFIsTiled( tif ) ) - { - if( !TIFFFillTile( tif, 0 ) ) - return; - } - else - { - if( !TIFFFillStrip( tif, 0 ) ) - return; - } - - TIFFSetField( tif, TIFFTAG_YCBCRSUBSAMPLING, - (uint16) sp->h_sampling, (uint16) sp->v_sampling ); -#endif /* CHECK_JPEG_YCBCR_SUBSAMPLING */ -} - static int -JPEGVGetField(TIFF* tif, ttag_t tag, va_list ap) +JPEGVGetField(TIFF* tif, uint32 tag, va_list ap) { JPEGState* sp = JState(tif); @@ -1772,21 +2091,6 @@ JPEGVGetField(TIFF* tif, ttag_t tag, va_list ap) case TIFFTAG_JPEGTABLESMODE: *va_arg(ap, int*) = sp->jpegtablesmode; break; - case TIFFTAG_YCBCRSUBSAMPLING: - JPEGFixupTestSubsampling( tif ); - return (*sp->vgetparent)(tif, tag, ap); - case TIFFTAG_FAXRECVPARAMS: - *va_arg(ap, uint32*) = sp->recvparams; - break; - case TIFFTAG_FAXSUBADDRESS: - *va_arg(ap, char**) = sp->subaddress; - break; - case TIFFTAG_FAXRECVTIME: - *va_arg(ap, uint32*) = sp->recvtime; - break; - case TIFFTAG_FAXDCS: - *va_arg(ap, char**) = sp->faxdcs; - break; default: return (*sp->vgetparent)(tif, tag, ap); } @@ -1799,21 +2103,15 @@ JPEGPrintDir(TIFF* tif, FILE* fd, long flags) JPEGState* sp = JState(tif); assert(sp != NULL); - (void) flags; - if (TIFFFieldSet(tif,FIELD_JPEGTABLES)) - fprintf(fd, " JPEG Tables: (%lu bytes)\n", - (unsigned long) sp->jpegtables_length); - if (TIFFFieldSet(tif,FIELD_RECVPARAMS)) - fprintf(fd, " Fax Receive Parameters: %08lx\n", - (unsigned long) sp->recvparams); - if (TIFFFieldSet(tif,FIELD_SUBADDRESS)) - fprintf(fd, " Fax SubAddress: %s\n", sp->subaddress); - if (TIFFFieldSet(tif,FIELD_RECVTIME)) - fprintf(fd, " Fax Receive Time: %lu secs\n", - (unsigned long) sp->recvtime); - if (TIFFFieldSet(tif,FIELD_FAXDCS)) - fprintf(fd, " Fax DCS: %s\n", sp->faxdcs); + + if( sp != NULL ) { + if (TIFFFieldSet(tif,FIELD_JPEGTABLES)) + fprintf(fd, " JPEG Tables: (%lu bytes)\n", + (unsigned long) sp->jpegtables_length); + if (sp->printdir) + (*sp->printdir)(tif, fd, flags); + } } static uint32 @@ -1824,7 +2122,7 @@ JPEGDefaultStripSize(TIFF* tif, uint32 s) s = (*sp->defsparent)(tif, s); if (s < td->td_imagelength) - s = TIFFroundup(s, td->td_ycbcrsubsampling[1] * DCTSIZE); + s = TIFFroundup_32(s, td->td_ycbcrsubsampling[1] * DCTSIZE); return (s); } @@ -1835,8 +2133,8 @@ JPEGDefaultTileSize(TIFF* tif, uint32* tw, uint32* th) TIFFDirectory *td = &tif->tif_dir; (*sp->deftparent)(tif, tw, th); - *tw = TIFFroundup(*tw, td->td_ycbcrsubsampling[0] * DCTSIZE); - *th = TIFFroundup(*th, td->td_ycbcrsubsampling[1] * DCTSIZE); + *tw = TIFFroundup_32(*tw, td->td_ycbcrsubsampling[0] * DCTSIZE); + *th = TIFFroundup_32(*th, td->td_ycbcrsubsampling[1] * DCTSIZE); } /* @@ -1861,19 +2159,15 @@ JPEGDefaultTileSize(TIFF* tif, uint32* tw, uint32* th) * NFW, Feb 3rd, 2003. */ -static int JPEGInitializeLibJPEG( TIFF * tif, int force_encode, int force_decode ) +static int JPEGInitializeLibJPEG( TIFF * tif, int decompress ) { JPEGState* sp = JState(tif); - uint32 *byte_counts = NULL; - int data_is_empty = TRUE; - int decompress; - if(sp->cinfo_initialized) { - if( force_encode && sp->cinfo.comm.is_decompressor ) + if( !decompress && sp->cinfo.comm.is_decompressor ) TIFFjpeg_destroy( sp ); - else if( force_decode && !sp->cinfo.comm.is_decompressor ) + else if( decompress && !sp->cinfo.comm.is_decompressor ) TIFFjpeg_destroy( sp ); else return 1; @@ -1882,41 +2176,11 @@ static int JPEGInitializeLibJPEG( TIFF * tif, int force_encode, int force_decode } /* - * Do we have tile data already? Make sure we initialize the - * the state in decompressor mode if we have tile data, even if we - * are not in read-only file access mode. - */ - if( TIFFIsTiled( tif ) - && TIFFGetField( tif, TIFFTAG_TILEBYTECOUNTS, &byte_counts ) - && byte_counts != NULL ) - { - data_is_empty = byte_counts[0] == 0; - } - if( !TIFFIsTiled( tif ) - && TIFFGetField( tif, TIFFTAG_STRIPBYTECOUNTS, &byte_counts) - && byte_counts != NULL ) - { - data_is_empty = byte_counts[0] == 0; - } - - if( force_decode ) - decompress = 1; - else if( force_encode ) - decompress = 0; - else if( tif->tif_mode == O_RDONLY ) - decompress = 1; - else if( data_is_empty ) - decompress = 0; - else - decompress = 1; - - /* * Initialize libjpeg. */ if ( decompress ) { if (!TIFFjpeg_create_decompress(sp)) return (0); - } else { if (!TIFFjpeg_create_compress(sp)) return (0); @@ -1937,7 +2201,7 @@ TIFFInitJPEG(TIFF* tif, int scheme) /* * Merge codec-specific tag information. */ - if (!_TIFFMergeFieldInfo(tif, jpegFieldInfo, N(jpegFieldInfo))) { + if (!_TIFFMergeFields(tif, jpegFields, TIFFArrayCount(jpegFields))) { TIFFErrorExt(tif->tif_clientdata, "TIFFInitJPEG", "Merging JPEG codec-specific tags failed"); @@ -1947,7 +2211,7 @@ TIFFInitJPEG(TIFF* tif, int scheme) /* * Allocate state block so tag methods have storage to record values. */ - tif->tif_data = (tidata_t) _TIFFmalloc(sizeof (JPEGState)); + tif->tif_data = (uint8*) _TIFFmalloc(sizeof (JPEGState)); if (tif->tif_data == NULL) { TIFFErrorExt(tif->tif_clientdata, @@ -1975,16 +2239,12 @@ TIFFInitJPEG(TIFF* tif, int scheme) sp->jpegquality = 75; /* Default IJG quality */ sp->jpegcolormode = JPEGCOLORMODE_RAW; sp->jpegtablesmode = JPEGTABLESMODE_QUANT | JPEGTABLESMODE_HUFF; - - sp->recvparams = 0; - sp->subaddress = NULL; - sp->faxdcs = NULL; - sp->ycbcrsampling_fetched = 0; /* * Install codec methods. */ + tif->tif_fixuptags = JPEGFixupTags; tif->tif_setupdecode = JPEGSetupDecode; tif->tif_predecode = JPEGPreDecode; tif->tif_decoderow = JPEGDecode; @@ -1995,7 +2255,7 @@ TIFFInitJPEG(TIFF* tif, int scheme) tif->tif_postencode = JPEGPostEncode; tif->tif_encoderow = JPEGEncode; tif->tif_encodestrip = JPEGEncode; - tif->tif_encodetile = JPEGEncode; + tif->tif_encodetile = JPEGEncode; tif->tif_cleanup = JPEGCleanup; sp->defsparent = tif->tif_defstripsize; tif->tif_defstripsize = JPEGDefaultStripSize; @@ -2014,22 +2274,31 @@ TIFFInitJPEG(TIFF* tif, int scheme) if( tif->tif_diroff == 0 ) { #define SIZE_OF_JPEGTABLES 2000 +/* +The following line assumes incorrectly that all JPEG-in-TIFF files will have +a JPEGTABLES tag generated and causes null-filled JPEGTABLES tags to be written +when the JPEG data is placed with TIFFWriteRawStrip. The field bit should be +set, anyway, later when actual JPEGTABLES header is generated, so removing it +here hopefully is harmless. TIFFSetFieldBit(tif, FIELD_JPEGTABLES); +*/ sp->jpegtables_length = SIZE_OF_JPEGTABLES; sp->jpegtables = (void *) _TIFFmalloc(sp->jpegtables_length); + // FIXME: NULL-deref after malloc failure _TIFFmemset(sp->jpegtables, 0, SIZE_OF_JPEGTABLES); #undef SIZE_OF_JPEGTABLES } - /* - * Mark the TIFFTAG_YCBCRSAMPLES as present even if it is not - * see: JPEGFixupTestSubsampling(). - */ - TIFFSetFieldBit( tif, FIELD_YCBCRSUBSAMPLING ); - return 1; } #endif /* JPEG_SUPPORT */ /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_luv.c b/src/3rdparty/libtiff/libtiff/tif_luv.c index be8fcea..eba6c08 100644 --- a/src/3rdparty/libtiff/libtiff/tif_luv.c +++ b/src/3rdparty/libtiff/libtiff/tif_luv.c @@ -1,4 +1,4 @@ -/* $Id: tif_luv.c,v 1.17.2.3 2009-06-30 17:06:25 fwarmerdam Exp $ */ +/* $Id: tif_luv.c,v 1.35 2011-04-02 20:54:09 bfriesen Exp $ */ /* * Copyright (c) 1997 Greg Ward Larson @@ -155,40 +155,44 @@ * State block for each open TIFF * file using LogLuv compression/decompression. */ -typedef struct logLuvState LogLuvState; +typedef struct logLuvState LogLuvState; struct logLuvState { - int user_datafmt; /* user data format */ - int encode_meth; /* encoding method */ - int pixel_size; /* bytes per pixel */ + int user_datafmt; /* user data format */ + int encode_meth; /* encoding method */ + int pixel_size; /* bytes per pixel */ - tidata_t* tbuf; /* translation buffer */ - int tbuflen; /* buffer length */ - void (*tfunc)(LogLuvState*, tidata_t, int); + uint8* tbuf; /* translation buffer */ + tmsize_t tbuflen; /* buffer length */ + void (*tfunc)(LogLuvState*, uint8*, tmsize_t); - TIFFVSetMethod vgetparent; /* super-class method */ - TIFFVSetMethod vsetparent; /* super-class method */ + TIFFVSetMethod vgetparent; /* super-class method */ + TIFFVSetMethod vsetparent; /* super-class method */ }; -#define DecoderState(tif) ((LogLuvState*) (tif)->tif_data) -#define EncoderState(tif) ((LogLuvState*) (tif)->tif_data) +#define DecoderState(tif) ((LogLuvState*) (tif)->tif_data) +#define EncoderState(tif) ((LogLuvState*) (tif)->tif_data) -#define SGILOGDATAFMT_UNKNOWN -1 +#define SGILOGDATAFMT_UNKNOWN -1 -#define MINRUN 4 /* minimum run length */ +#define MINRUN 4 /* minimum run length */ /* * Decode a string of 16-bit gray pixels. */ static int -LogL16Decode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) +LogL16Decode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s) { + static const char module[] = "LogL16Decode"; LogLuvState* sp = DecoderState(tif); - int shft, i, npixels; + int shft; + tmsize_t i; + tmsize_t npixels; unsigned char* bp; int16* tp; int16 b; - int cc, rc; + tmsize_t cc; + int rc; assert(s == 0); assert(sp != NULL); @@ -201,15 +205,15 @@ LogL16Decode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) assert(sp->tbuflen >= npixels); tp = (int16*) sp->tbuf; } - _TIFFmemset((tdata_t) tp, 0, npixels*sizeof (tp[0])); + _TIFFmemset((void*) tp, 0, npixels*sizeof (tp[0])); bp = (unsigned char*) tif->tif_rawcp; cc = tif->tif_rawcc; - /* get each byte string */ + /* get each byte string */ for (shft = 2*8; (shft -= 8) >= 0; ) { for (i = 0; i < npixels && cc > 0; ) if (*bp >= 128) { /* run */ - rc = *bp++ + (2-128); + rc = *bp++ + (2-128); /* TODO: potential input buffer overrun when decoding corrupt or truncated data */ b = (int16)(*bp++ << shft); cc -= 2; while (rc-- && i < npixels) @@ -220,16 +224,24 @@ LogL16Decode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) tp[i++] |= (int16)*bp++ << shft; } if (i != npixels) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "LogL16Decode: Not enough data at row %d (short %d pixels)", - tif->tif_row, npixels - i); - tif->tif_rawcp = (tidata_t) bp; +#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) + TIFFErrorExt(tif->tif_clientdata, module, + "Not enough data at row %lu (short %I64d pixels)", + (unsigned long) tif->tif_row, + (unsigned __int64) (npixels - i)); +#else + TIFFErrorExt(tif->tif_clientdata, module, + "Not enough data at row %lu (short %llu pixels)", + (unsigned long) tif->tif_row, + (unsigned long long) (npixels - i)); +#endif + tif->tif_rawcp = (uint8*) bp; tif->tif_rawcc = cc; return (0); } } (*sp->tfunc)(sp, op, npixels); - tif->tif_rawcp = (tidata_t) bp; + tif->tif_rawcp = (uint8*) bp; tif->tif_rawcc = cc; return (1); } @@ -238,10 +250,13 @@ LogL16Decode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) * Decode a string of 24-bit pixels. */ static int -LogLuvDecode24(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) +LogLuvDecode24(TIFF* tif, uint8* op, tmsize_t occ, uint16 s) { + static const char module[] = "LogLuvDecode24"; LogLuvState* sp = DecoderState(tif); - int cc, i, npixels; + tmsize_t cc; + tmsize_t i; + tmsize_t npixels; unsigned char* bp; uint32* tp; @@ -256,7 +271,7 @@ LogLuvDecode24(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) assert(sp->tbuflen >= npixels); tp = (uint32 *) sp->tbuf; } - /* copy to array of uint32 */ + /* copy to array of uint32 */ bp = (unsigned char*) tif->tif_rawcp; cc = tif->tif_rawcc; for (i = 0; i < npixels && cc > 0; i++) { @@ -264,12 +279,20 @@ LogLuvDecode24(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) bp += 3; cc -= 3; } - tif->tif_rawcp = (tidata_t) bp; + tif->tif_rawcp = (uint8*) bp; tif->tif_rawcc = cc; if (i != npixels) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "LogLuvDecode24: Not enough data at row %d (short %d pixels)", - tif->tif_row, npixels - i); +#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) + TIFFErrorExt(tif->tif_clientdata, module, + "Not enough data at row %lu (short %I64d pixels)", + (unsigned long) tif->tif_row, + (unsigned __int64) (npixels - i)); +#else + TIFFErrorExt(tif->tif_clientdata, module, + "Not enough data at row %lu (short %llu pixels)", + (unsigned long) tif->tif_row, + (unsigned long long) (npixels - i)); +#endif return (0); } (*sp->tfunc)(sp, op, npixels); @@ -280,14 +303,18 @@ LogLuvDecode24(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) * Decode a string of 32-bit pixels. */ static int -LogLuvDecode32(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) +LogLuvDecode32(TIFF* tif, uint8* op, tmsize_t occ, uint16 s) { + static const char module[] = "LogLuvDecode32"; LogLuvState* sp; - int shft, i, npixels; + int shft; + tmsize_t i; + tmsize_t npixels; unsigned char* bp; uint32* tp; uint32 b; - int cc, rc; + tmsize_t cc; + int rc; assert(s == 0); sp = DecoderState(tif); @@ -301,17 +328,17 @@ LogLuvDecode32(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) assert(sp->tbuflen >= npixels); tp = (uint32*) sp->tbuf; } - _TIFFmemset((tdata_t) tp, 0, npixels*sizeof (tp[0])); + _TIFFmemset((void*) tp, 0, npixels*sizeof (tp[0])); bp = (unsigned char*) tif->tif_rawcp; cc = tif->tif_rawcc; - /* get each byte string */ + /* get each byte string */ for (shft = 4*8; (shft -= 8) >= 0; ) { for (i = 0; i < npixels && cc > 0; ) if (*bp >= 128) { /* run */ rc = *bp++ + (2-128); b = (uint32)*bp++ << shft; - cc -= 2; + cc -= 2; /* TODO: potential input buffer overrun when decoding corrupt or truncated data */ while (rc-- && i < npixels) tp[i++] |= b; } else { /* non-run */ @@ -320,16 +347,24 @@ LogLuvDecode32(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) tp[i++] |= (uint32)*bp++ << shft; } if (i != npixels) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "LogLuvDecode32: Not enough data at row %d (short %d pixels)", - tif->tif_row, npixels - i); - tif->tif_rawcp = (tidata_t) bp; +#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) + TIFFErrorExt(tif->tif_clientdata, module, + "Not enough data at row %lu (short %I64d pixels)", + (unsigned long) tif->tif_row, + (unsigned __int64) (npixels - i)); +#else + TIFFErrorExt(tif->tif_clientdata, module, + "Not enough data at row %lu (short %llu pixels)", + (unsigned long) tif->tif_row, + (unsigned long long) (npixels - i)); +#endif + tif->tif_rawcp = (uint8*) bp; tif->tif_rawcc = cc; return (0); } } (*sp->tfunc)(sp, op, npixels); - tif->tif_rawcp = (tidata_t) bp; + tif->tif_rawcp = (uint8*) bp; tif->tif_rawcc = cc; return (1); } @@ -340,9 +375,9 @@ LogLuvDecode32(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) * is row by row. */ static int -LogLuvDecodeStrip(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) +LogLuvDecodeStrip(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s) { - tsize_t rowlen = TIFFScanlineSize(tif); + tmsize_t rowlen = TIFFScanlineSize(tif); assert(cc%rowlen == 0); while (cc && (*tif->tif_decoderow)(tif, bp, rowlen, s)) @@ -356,9 +391,9 @@ LogLuvDecodeStrip(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) * is row by row. */ static int -LogLuvDecodeTile(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) +LogLuvDecodeTile(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s) { - tsize_t rowlen = TIFFTileRowSize(tif); + tmsize_t rowlen = TIFFTileRowSize(tif); assert(cc%rowlen == 0); while (cc && (*tif->tif_decoderow)(tif, bp, rowlen, s)) @@ -370,14 +405,19 @@ LogLuvDecodeTile(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) * Encode a row of 16-bit pixels. */ static int -LogL16Encode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) +LogL16Encode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s) { LogLuvState* sp = EncoderState(tif); - int shft, i, j, npixels; - tidata_t op; + int shft; + tmsize_t i; + tmsize_t j; + tmsize_t npixels; + uint8* op; int16* tp; int16 b; - int occ, rc=0, mask, beg; + tmsize_t occ; + int rc=0, mask; + tmsize_t beg; assert(s == 0); assert(sp != NULL); @@ -390,7 +430,7 @@ LogL16Encode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) assert(sp->tbuflen >= npixels); (*sp->tfunc)(sp, bp, npixels); } - /* compress each byte string */ + /* compress each byte string */ op = tif->tif_rawcp; occ = tif->tif_rawdatasize - tif->tif_rawcc; for (shft = 2*8; (shft -= 8) >= 0; ) @@ -408,7 +448,7 @@ LogL16Encode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) b = (int16) (tp[beg] & mask); rc = 1; while (rc < 127+2 && beg+rc < npixels && - (tp[beg+rc] & mask) == b) + (tp[beg+rc] & mask) == b) rc++; if (rc >= MINRUN) break; /* long enough */ @@ -417,33 +457,33 @@ LogL16Encode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) b = (int16) (tp[i] & mask);/*check short run */ j = i+1; while ((tp[j++] & mask) == b) - if (j == beg) { - *op++ = (tidataval_t)(128-2+j-i); - *op++ = (tidataval_t) (b >> shft); - occ -= 2; - i = beg; - break; - } + if (j == beg) { + *op++ = (uint8)(128-2+j-i); + *op++ = (uint8)(b >> shft); + occ -= 2; + i = beg; + break; + } } while (i < beg) { /* write out non-run */ if ((j = beg-i) > 127) j = 127; if (occ < j+3) { - tif->tif_rawcp = op; - tif->tif_rawcc = tif->tif_rawdatasize - occ; - if (!TIFFFlushData1(tif)) - return (-1); - op = tif->tif_rawcp; - occ = tif->tif_rawdatasize - tif->tif_rawcc; + tif->tif_rawcp = op; + tif->tif_rawcc = tif->tif_rawdatasize - occ; + if (!TIFFFlushData1(tif)) + return (-1); + op = tif->tif_rawcp; + occ = tif->tif_rawdatasize - tif->tif_rawcc; } - *op++ = (tidataval_t) j; occ--; + *op++ = (uint8) j; occ--; while (j--) { - *op++ = (tidataval_t) (tp[i++] >> shft & 0xff); + *op++ = (uint8) (tp[i++] >> shft & 0xff); occ--; } } if (rc >= MINRUN) { /* write out run */ - *op++ = (tidataval_t) (128-2+rc); - *op++ = (tidataval_t) (tp[beg] >> shft & 0xff); + *op++ = (uint8) (128-2+rc); + *op++ = (uint8) (tp[beg] >> shft & 0xff); occ -= 2; } else rc = 0; @@ -458,11 +498,13 @@ LogL16Encode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) * Encode a row of 24-bit pixels. */ static int -LogLuvEncode24(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) +LogLuvEncode24(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s) { LogLuvState* sp = EncoderState(tif); - int i, npixels, occ; - tidata_t op; + tmsize_t i; + tmsize_t npixels; + tmsize_t occ; + uint8* op; uint32* tp; assert(s == 0); @@ -476,7 +518,7 @@ LogLuvEncode24(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) assert(sp->tbuflen >= npixels); (*sp->tfunc)(sp, bp, npixels); } - /* write out encoded pixels */ + /* write out encoded pixels */ op = tif->tif_rawcp; occ = tif->tif_rawdatasize - tif->tif_rawcc; for (i = npixels; i--; ) { @@ -488,9 +530,9 @@ LogLuvEncode24(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) op = tif->tif_rawcp; occ = tif->tif_rawdatasize - tif->tif_rawcc; } - *op++ = (tidataval_t)(*tp >> 16); - *op++ = (tidataval_t)(*tp >> 8 & 0xff); - *op++ = (tidataval_t)(*tp++ & 0xff); + *op++ = (uint8)(*tp >> 16); + *op++ = (uint8)(*tp >> 8 & 0xff); + *op++ = (uint8)(*tp++ & 0xff); occ -= 3; } tif->tif_rawcp = op; @@ -503,14 +545,19 @@ LogLuvEncode24(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) * Encode a row of 32-bit pixels. */ static int -LogLuvEncode32(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) +LogLuvEncode32(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s) { LogLuvState* sp = EncoderState(tif); - int shft, i, j, npixels; - tidata_t op; + int shft; + tmsize_t i; + tmsize_t j; + tmsize_t npixels; + uint8* op; uint32* tp; uint32 b; - int occ, rc=0, mask, beg; + tmsize_t occ; + int rc=0, mask; + tmsize_t beg; assert(s == 0); assert(sp != NULL); @@ -524,7 +571,7 @@ LogLuvEncode32(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) assert(sp->tbuflen >= npixels); (*sp->tfunc)(sp, bp, npixels); } - /* compress each byte string */ + /* compress each byte string */ op = tif->tif_rawcp; occ = tif->tif_rawdatasize - tif->tif_rawcc; for (shft = 4*8; (shft -= 8) >= 0; ) @@ -552,8 +599,8 @@ LogLuvEncode32(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) j = i+1; while ((tp[j++] & mask) == b) if (j == beg) { - *op++ = (tidataval_t)(128-2+j-i); - *op++ = (tidataval_t)(b >> shft); + *op++ = (uint8)(128-2+j-i); + *op++ = (uint8)(b >> shft); occ -= 2; i = beg; break; @@ -569,15 +616,15 @@ LogLuvEncode32(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) op = tif->tif_rawcp; occ = tif->tif_rawdatasize - tif->tif_rawcc; } - *op++ = (tidataval_t) j; occ--; + *op++ = (uint8) j; occ--; while (j--) { - *op++ = (tidataval_t)(tp[i++] >> shft & 0xff); + *op++ = (uint8)(tp[i++] >> shft & 0xff); occ--; } } if (rc >= MINRUN) { /* write out run */ - *op++ = (tidataval_t) (128-2+rc); - *op++ = (tidataval_t)(tp[beg] >> shft & 0xff); + *op++ = (uint8) (128-2+rc); + *op++ = (uint8)(tp[beg] >> shft & 0xff); occ -= 2; } else rc = 0; @@ -593,9 +640,9 @@ LogLuvEncode32(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) * avoid encoding runs across row boundaries. */ static int -LogLuvEncodeStrip(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) +LogLuvEncodeStrip(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s) { - tsize_t rowlen = TIFFScanlineSize(tif); + tmsize_t rowlen = TIFFScanlineSize(tif); assert(cc%rowlen == 0); while (cc && (*tif->tif_encoderow)(tif, bp, rowlen, s) == 1) @@ -608,9 +655,9 @@ LogLuvEncodeStrip(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) * avoid encoding runs across row boundaries. */ static int -LogLuvEncodeTile(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) +LogLuvEncodeTile(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s) { - tsize_t rowlen = TIFFTileRowSize(tif); + tmsize_t rowlen = TIFFTileRowSize(tif); assert(cc%rowlen == 0); while (cc && (*tif->tif_encoderow)(tif, bp, rowlen, s) == 1) @@ -676,7 +723,7 @@ LogL16fromY(double Y, int em) /* get 16-bit LogL from Y */ } static void -L16toY(LogLuvState* sp, tidata_t op, int n) +L16toY(LogLuvState* sp, uint8* op, tmsize_t n) { int16* l16 = (int16*) sp->tbuf; float* yp = (float*) op; @@ -686,7 +733,7 @@ L16toY(LogLuvState* sp, tidata_t op, int n) } static void -L16toGry(LogLuvState* sp, tidata_t op, int n) +L16toGry(LogLuvState* sp, uint8* op, tmsize_t n) { int16* l16 = (int16*) sp->tbuf; uint8* gp = (uint8*) op; @@ -698,7 +745,7 @@ L16toGry(LogLuvState* sp, tidata_t op, int n) } static void -L16fromY(LogLuvState* sp, tidata_t op, int n) +L16fromY(LogLuvState* sp, uint8* op, tmsize_t n) { int16* l16 = (int16*) sp->tbuf; float* yp = (float*) op; @@ -760,7 +807,7 @@ oog_encode(double u, double v) /* encode out-of-gamut chroma */ static int oog_table[NANGLES]; static int initialized = 0; register int i; - + if (!initialized) { /* set up perimeter table */ double eps[NANGLES], ua, va, ang, epsa; int ui, vi, ustep; @@ -774,7 +821,7 @@ oog_encode(double u, double v) /* encode out-of-gamut chroma */ for (ui = uv_row[vi].nus-1; ui >= 0; ui -= ustep) { ua = uv_row[vi].ustart + (ui+.5)*UV_SQSIZ; ang = uv2ang(ua, va); - i = (int) ang; + i = (int) ang; epsa = fabs(ang - (i+.5)); if (epsa < eps[i]) { oog_table[i] = uv_row[vi].ncum + ui; @@ -916,9 +963,9 @@ LogLuv24fromXYZ(float XYZ[3], int em) } static void -Luv24toXYZ(LogLuvState* sp, tidata_t op, int n) +Luv24toXYZ(LogLuvState* sp, uint8* op, tmsize_t n) { - uint32* luv = (uint32*) sp->tbuf; + uint32* luv = (uint32*) sp->tbuf; float* xyz = (float*) op; while (n-- > 0) { @@ -929,9 +976,9 @@ Luv24toXYZ(LogLuvState* sp, tidata_t op, int n) } static void -Luv24toLuv48(LogLuvState* sp, tidata_t op, int n) +Luv24toLuv48(LogLuvState* sp, uint8* op, tmsize_t n) { - uint32* luv = (uint32*) sp->tbuf; + uint32* luv = (uint32*) sp->tbuf; int16* luv3 = (int16*) op; while (n-- > 0) { @@ -949,9 +996,9 @@ Luv24toLuv48(LogLuvState* sp, tidata_t op, int n) } static void -Luv24toRGB(LogLuvState* sp, tidata_t op, int n) +Luv24toRGB(LogLuvState* sp, uint8* op, tmsize_t n) { - uint32* luv = (uint32*) sp->tbuf; + uint32* luv = (uint32*) sp->tbuf; uint8* rgb = (uint8*) op; while (n-- > 0) { @@ -964,9 +1011,9 @@ Luv24toRGB(LogLuvState* sp, tidata_t op, int n) } static void -Luv24fromXYZ(LogLuvState* sp, tidata_t op, int n) +Luv24fromXYZ(LogLuvState* sp, uint8* op, tmsize_t n) { - uint32* luv = (uint32*) sp->tbuf; + uint32* luv = (uint32*) sp->tbuf; float* xyz = (float*) op; while (n-- > 0) { @@ -976,9 +1023,9 @@ Luv24fromXYZ(LogLuvState* sp, tidata_t op, int n) } static void -Luv24fromLuv48(LogLuvState* sp, tidata_t op, int n) +Luv24fromLuv48(LogLuvState* sp, uint8* op, tmsize_t n) { - uint32* luv = (uint32*) sp->tbuf; + uint32* luv = (uint32*) sp->tbuf; int16* luv3 = (int16*) op; while (n-- > 0) { @@ -1057,9 +1104,9 @@ LogLuv32fromXYZ(float XYZ[3], int em) } static void -Luv32toXYZ(LogLuvState* sp, tidata_t op, int n) +Luv32toXYZ(LogLuvState* sp, uint8* op, tmsize_t n) { - uint32* luv = (uint32*) sp->tbuf; + uint32* luv = (uint32*) sp->tbuf; float* xyz = (float*) op; while (n-- > 0) { @@ -1069,9 +1116,9 @@ Luv32toXYZ(LogLuvState* sp, tidata_t op, int n) } static void -Luv32toLuv48(LogLuvState* sp, tidata_t op, int n) +Luv32toLuv48(LogLuvState* sp, uint8* op, tmsize_t n) { - uint32* luv = (uint32*) sp->tbuf; + uint32* luv = (uint32*) sp->tbuf; int16* luv3 = (int16*) op; while (n-- > 0) { @@ -1087,9 +1134,9 @@ Luv32toLuv48(LogLuvState* sp, tidata_t op, int n) } static void -Luv32toRGB(LogLuvState* sp, tidata_t op, int n) +Luv32toRGB(LogLuvState* sp, uint8* op, tmsize_t n) { - uint32* luv = (uint32*) sp->tbuf; + uint32* luv = (uint32*) sp->tbuf; uint8* rgb = (uint8*) op; while (n-- > 0) { @@ -1102,9 +1149,9 @@ Luv32toRGB(LogLuvState* sp, tidata_t op, int n) } static void -Luv32fromXYZ(LogLuvState* sp, tidata_t op, int n) +Luv32fromXYZ(LogLuvState* sp, uint8* op, tmsize_t n) { - uint32* luv = (uint32*) sp->tbuf; + uint32* luv = (uint32*) sp->tbuf; float* xyz = (float*) op; while (n-- > 0) { @@ -1114,7 +1161,7 @@ Luv32fromXYZ(LogLuvState* sp, tidata_t op, int n) } static void -Luv32fromLuv48(LogLuvState* sp, tidata_t op, int n) +Luv32fromLuv48(LogLuvState* sp, uint8* op, tmsize_t n) { uint32* luv = (uint32*) sp->tbuf; int16* luv3 = (int16*) op; @@ -1137,7 +1184,7 @@ Luv32fromLuv48(LogLuvState* sp, tidata_t op, int n) } static void -_logLuvNop(LogLuvState* sp, tidata_t op, int n) +_logLuvNop(LogLuvState* sp, uint8* op, tmsize_t n) { (void) sp; (void) op; (void) n; } @@ -1161,10 +1208,10 @@ LogL16GuessDataFmt(TIFFDirectory *td) return (SGILOGDATAFMT_UNKNOWN); } -static uint32 -multiply(size_t m1, size_t m2) +static tmsize_t +multiply_ms(tmsize_t m1, tmsize_t m2) { - uint32 bytes = m1 * m2; + tmsize_t bytes = m1 * m2; if (m1 && bytes / m1 != m2) bytes = 0; @@ -1175,9 +1222,9 @@ multiply(size_t m1, size_t m2) static int LogL16InitState(TIFF* tif) { + static const char module[] = "LogL16InitState"; TIFFDirectory *td = &tif->tif_dir; LogLuvState* sp = DecoderState(tif); - static const char module[] = "LogL16InitState"; assert(sp != NULL); assert(td->td_photometric == PHOTOMETRIC_LOGL); @@ -1196,18 +1243,17 @@ LogL16InitState(TIFF* tif) sp->pixel_size = sizeof (uint8); break; default: - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, + TIFFErrorExt(tif->tif_clientdata, module, "No support for converting user data format to LogL"); return (0); } if( isTiled(tif) ) - sp->tbuflen = multiply(td->td_tilewidth, td->td_tilelength); + sp->tbuflen = multiply_ms(td->td_tilewidth, td->td_tilelength); else - sp->tbuflen = multiply(td->td_imagewidth, td->td_rowsperstrip); - if (multiply(sp->tbuflen, sizeof (int16)) == 0 || - (sp->tbuf = (tidata_t*) _TIFFmalloc(sp->tbuflen * sizeof (int16))) == NULL) { - TIFFErrorExt(tif->tif_clientdata, module, "%s: No space for SGILog translation buffer", - tif->tif_name); + sp->tbuflen = multiply_ms(td->td_imagewidth, td->td_rowsperstrip); + if (multiply_ms(sp->tbuflen, sizeof (int16)) == 0 || + (sp->tbuf = (uint8*) _TIFFmalloc(sp->tbuflen * sizeof (int16))) == NULL) { + TIFFErrorExt(tif->tif_clientdata, module, "No space for SGILog translation buffer"); return (0); } return (1); @@ -1268,9 +1314,9 @@ LogLuvGuessDataFmt(TIFFDirectory *td) static int LogLuvInitState(TIFF* tif) { + static const char module[] = "LogLuvInitState"; TIFFDirectory* td = &tif->tif_dir; LogLuvState* sp = DecoderState(tif); - static const char module[] = "LogLuvInitState"; assert(sp != NULL); assert(td->td_photometric == PHOTOMETRIC_LOGLUV); @@ -1297,26 +1343,33 @@ LogLuvInitState(TIFF* tif) sp->pixel_size = 3*sizeof (uint8); break; default: - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, + TIFFErrorExt(tif->tif_clientdata, module, "No support for converting user data format to LogLuv"); return (0); } if( isTiled(tif) ) - sp->tbuflen = multiply(td->td_tilewidth, td->td_tilelength); + sp->tbuflen = multiply_ms(td->td_tilewidth, td->td_tilelength); else - sp->tbuflen = multiply(td->td_imagewidth, td->td_rowsperstrip); - if (multiply(sp->tbuflen, sizeof (uint32)) == 0 || - (sp->tbuf = (tidata_t*) _TIFFmalloc(sp->tbuflen * sizeof (uint32))) == NULL) { - TIFFErrorExt(tif->tif_clientdata, module, "%s: No space for SGILog translation buffer", - tif->tif_name); + sp->tbuflen = multiply_ms(td->td_imagewidth, td->td_rowsperstrip); + if (multiply_ms(sp->tbuflen, sizeof (uint32)) == 0 || + (sp->tbuf = (uint8*) _TIFFmalloc(sp->tbuflen * sizeof (uint32))) == NULL) { + TIFFErrorExt(tif->tif_clientdata, module, "No space for SGILog translation buffer"); return (0); } return (1); } static int +LogLuvFixupTags(TIFF* tif) +{ + (void) tif; + return (1); +} + +static int LogLuvSetupDecode(TIFF* tif) { + static const char module[] = "LogLuvSetupDecode"; LogLuvState* sp = DecoderState(tif); TIFFDirectory* td = &tif->tif_dir; @@ -1329,10 +1382,10 @@ LogLuvSetupDecode(TIFF* tif) tif->tif_decoderow = LogLuvDecode24; switch (sp->user_datafmt) { case SGILOGDATAFMT_FLOAT: - sp->tfunc = Luv24toXYZ; + sp->tfunc = Luv24toXYZ; break; case SGILOGDATAFMT_16BIT: - sp->tfunc = Luv24toLuv48; + sp->tfunc = Luv24toLuv48; break; case SGILOGDATAFMT_8BIT: sp->tfunc = Luv24toRGB; @@ -1367,8 +1420,8 @@ LogLuvSetupDecode(TIFF* tif) } return (1); default: - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Inappropriate photometric interpretation %d for SGILog compression; %s", + TIFFErrorExt(tif->tif_clientdata, module, + "Inappropriate photometric interpretation %d for SGILog compression; %s", td->td_photometric, "must be either LogLUV or LogL"); break; } @@ -1378,6 +1431,7 @@ LogLuvSetupDecode(TIFF* tif) static int LogLuvSetupEncode(TIFF* tif) { + static const char module[] = "LogLuvSetupEncode"; LogLuvState* sp = EncoderState(tif); TIFFDirectory* td = &tif->tif_dir; @@ -1392,7 +1446,7 @@ LogLuvSetupEncode(TIFF* tif) sp->tfunc = Luv24fromXYZ; break; case SGILOGDATAFMT_16BIT: - sp->tfunc = Luv24fromLuv48; + sp->tfunc = Luv24fromLuv48; break; case SGILOGDATAFMT_RAW: break; @@ -1400,13 +1454,13 @@ LogLuvSetupEncode(TIFF* tif) goto notsupported; } } else { - tif->tif_encoderow = LogLuvEncode32; + tif->tif_encoderow = LogLuvEncode32; switch (sp->user_datafmt) { case SGILOGDATAFMT_FLOAT: - sp->tfunc = Luv32fromXYZ; + sp->tfunc = Luv32fromXYZ; break; case SGILOGDATAFMT_16BIT: - sp->tfunc = Luv32fromLuv48; + sp->tfunc = Luv32fromLuv48; break; case SGILOGDATAFMT_RAW: break; @@ -1418,7 +1472,7 @@ LogLuvSetupEncode(TIFF* tif) case PHOTOMETRIC_LOGL: if (!LogL16InitState(tif)) break; - tif->tif_encoderow = LogL16Encode; + tif->tif_encoderow = LogL16Encode; switch (sp->user_datafmt) { case SGILOGDATAFMT_FLOAT: sp->tfunc = L16fromY; @@ -1430,14 +1484,14 @@ LogLuvSetupEncode(TIFF* tif) } break; default: - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Inappropriate photometric interpretation %d for SGILog compression; %s", - td->td_photometric, "must be either LogLUV or LogL"); + TIFFErrorExt(tif->tif_clientdata, module, + "Inappropriate photometric interpretation %d for SGILog compression; %s", + td->td_photometric, "must be either LogLUV or LogL"); break; } return (1); notsupported: - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, + TIFFErrorExt(tif->tif_clientdata, module, "SGILog compression supported only for %s, or raw data", td->td_photometric == PHOTOMETRIC_LOGL ? "Y, L" : "XYZ, Luv"); return (0); @@ -1480,14 +1534,15 @@ LogLuvCleanup(TIFF* tif) } static int -LogLuvVSetField(TIFF* tif, ttag_t tag, va_list ap) +LogLuvVSetField(TIFF* tif, uint32 tag, va_list ap) { + static const char module[] = "LogLuvVSetField"; LogLuvState* sp = DecoderState(tif); int bps, fmt; switch (tag) { case TIFFTAG_SGILOGDATAFMT: - sp->user_datafmt = va_arg(ap, int); + sp->user_datafmt = (int) va_arg(ap, int); /* * Tweak the TIFF header so that the rest of libtiff knows what * size of data will be passed between app and library, and @@ -1519,16 +1574,16 @@ LogLuvVSetField(TIFF* tif, ttag_t tag, va_list ap) /* * Must recalculate sizes should bits/sample change. */ - tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tsize_t) -1; + tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tmsize_t) -1; tif->tif_scanlinesize = TIFFScanlineSize(tif); return (1); case TIFFTAG_SGILOGENCODE: - sp->encode_meth = va_arg(ap, int); + sp->encode_meth = (int) va_arg(ap, int); if (sp->encode_meth != SGILOGENCODE_NODITHER && - sp->encode_meth != SGILOGENCODE_RANDITHER) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Unknown encoding %d for LogLuv compression", - sp->encode_meth); + sp->encode_meth != SGILOGENCODE_RANDITHER) { + TIFFErrorExt(tif->tif_clientdata, module, + "Unknown encoding %d for LogLuv compression", + sp->encode_meth); return (0); } return (1); @@ -1538,7 +1593,7 @@ LogLuvVSetField(TIFF* tif, ttag_t tag, va_list ap) } static int -LogLuvVGetField(TIFF* tif, ttag_t tag, va_list ap) +LogLuvVGetField(TIFF* tif, uint32 tag, va_list ap) { LogLuvState *sp = (LogLuvState *)tif->tif_data; @@ -1551,11 +1606,9 @@ LogLuvVGetField(TIFF* tif, ttag_t tag, va_list ap) } } -static const TIFFFieldInfo LogLuvFieldInfo[] = { - { TIFFTAG_SGILOGDATAFMT, 0, 0, TIFF_SHORT, FIELD_PSEUDO, - TRUE, FALSE, "SGILogDataFmt"}, - { TIFFTAG_SGILOGENCODE, 0, 0, TIFF_SHORT, FIELD_PSEUDO, - TRUE, FALSE, "SGILogEncode"} +static const TIFFField LogLuvFields[] = { + { TIFFTAG_SGILOGDATAFMT, 0, 0, TIFF_SHORT, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "SGILogDataFmt", NULL}, + { TIFFTAG_SGILOGENCODE, 0, 0, TIFF_SHORT, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "SGILogEncode", NULL} }; int @@ -1569,24 +1622,24 @@ TIFFInitSGILog(TIFF* tif, int scheme) /* * Merge codec-specific tag information. */ - if (!_TIFFMergeFieldInfo(tif, LogLuvFieldInfo, - TIFFArrayCount(LogLuvFieldInfo))) { + if (!_TIFFMergeFields(tif, LogLuvFields, + TIFFArrayCount(LogLuvFields))) { TIFFErrorExt(tif->tif_clientdata, module, - "Merging SGILog codec-specific tags failed"); + "Merging SGILog codec-specific tags failed"); return 0; } /* * Allocate state block so tag methods have storage to record values. */ - tif->tif_data = (tidata_t) _TIFFmalloc(sizeof (LogLuvState)); + tif->tif_data = (uint8*) _TIFFmalloc(sizeof (LogLuvState)); if (tif->tif_data == NULL) goto bad; sp = (LogLuvState*) tif->tif_data; - _TIFFmemset((tdata_t)sp, 0, sizeof (*sp)); + _TIFFmemset((void*)sp, 0, sizeof (*sp)); sp->user_datafmt = SGILOGDATAFMT_UNKNOWN; sp->encode_meth = (scheme == COMPRESSION_SGILOG24) ? - SGILOGENCODE_RANDITHER : SGILOGENCODE_NODITHER; + SGILOGENCODE_RANDITHER : SGILOGENCODE_NODITHER; sp->tfunc = _logLuvNop; /* @@ -1594,16 +1647,17 @@ TIFFInitSGILog(TIFF* tif, int scheme) * NB: tif_decoderow & tif_encoderow are filled * in at setup time. */ + tif->tif_fixuptags = LogLuvFixupTags; tif->tif_setupdecode = LogLuvSetupDecode; tif->tif_decodestrip = LogLuvDecodeStrip; tif->tif_decodetile = LogLuvDecodeTile; tif->tif_setupencode = LogLuvSetupEncode; - tif->tif_encodestrip = LogLuvEncodeStrip; + tif->tif_encodestrip = LogLuvEncodeStrip; tif->tif_encodetile = LogLuvEncodeTile; tif->tif_close = LogLuvClose; tif->tif_cleanup = LogLuvCleanup; - /* + /* * Override parent get/set field methods. */ sp->vgetparent = tif->tif_tagmethods.vgetfield; @@ -1620,3 +1674,10 @@ bad: #endif /* LOGLUV_SUPPORT */ /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_lzw.c b/src/3rdparty/libtiff/libtiff/tif_lzw.c index bc4dac6..fd9c7a0 100644 --- a/src/3rdparty/libtiff/libtiff/tif_lzw.c +++ b/src/3rdparty/libtiff/libtiff/tif_lzw.c @@ -1,4 +1,4 @@ -/* $Id: tif_lzw.c,v 1.29.2.5 2009-06-22 04:57:31 fwarmerdam Exp $ */ +/* $Id: tif_lzw.c,v 1.45 2011-04-02 20:54:09 bfriesen Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler @@ -27,7 +27,7 @@ #include "tiffiop.h" #ifdef LZW_SUPPORT /* - * TIFF Library. + * TIFF Library. * Rev 5.0 Lempel-Ziv & Welch Compression Support * * This code is derived from the compress program whose code is @@ -53,34 +53,34 @@ * * Future revisions to the TIFF spec are expected to "clarify this issue". */ -#define LZW_COMPAT /* include backwards compatibility code */ +#define LZW_COMPAT /* include backwards compatibility code */ /* * Each strip of data is supposed to be terminated by a CODE_EOI. * If the following #define is included, the decoder will also * check for end-of-strip w/o seeing this code. This makes the * library more robust, but also slower. */ -#define LZW_CHECKEOS /* include checks for strips w/o EOI code */ +#define LZW_CHECKEOS /* include checks for strips w/o EOI code */ #define MAXCODE(n) ((1L<<(n))-1) /* * The TIFF spec specifies that encoded bit * strings range from 9 to 12 bits. */ -#define BITS_MIN 9 /* start with 9 bits */ -#define BITS_MAX 12 /* max of 12 bit strings */ +#define BITS_MIN 9 /* start with 9 bits */ +#define BITS_MAX 12 /* max of 12 bit strings */ /* predefined codes */ -#define CODE_CLEAR 256 /* code to clear string table */ -#define CODE_EOI 257 /* end-of-information code */ -#define CODE_FIRST 258 /* first free code entry */ -#define CODE_MAX MAXCODE(BITS_MAX) -#define HSIZE 9001L /* 91% occupancy */ -#define HSHIFT (13-8) +#define CODE_CLEAR 256 /* code to clear string table */ +#define CODE_EOI 257 /* end-of-information code */ +#define CODE_FIRST 258 /* first free code entry */ +#define CODE_MAX MAXCODE(BITS_MAX) +#define HSIZE 9001L /* 91% occupancy */ +#define HSHIFT (13-8) #ifdef LZW_COMPAT /* NB: +1024 is for compatibility with old files */ -#define CSIZE (MAXCODE(BITS_MAX)+1024L) +#define CSIZE (MAXCODE(BITS_MAX)+1024L) #else -#define CSIZE (MAXCODE(BITS_MAX)+1L) +#define CSIZE (MAXCODE(BITS_MAX)+1L) #endif /* @@ -88,23 +88,23 @@ * compression/decompression. Note that the predictor * state block must be first in this data structure. */ -typedef struct { - TIFFPredictorState predict; /* predictor super class */ +typedef struct { + TIFFPredictorState predict; /* predictor super class */ - unsigned short nbits; /* # of bits/code */ - unsigned short maxcode; /* maximum code for lzw_nbits */ - unsigned short free_ent; /* next free entry in hash table */ - long nextdata; /* next bits of i/o */ - long nextbits; /* # of valid bits in lzw_nextdata */ + unsigned short nbits; /* # of bits/code */ + unsigned short maxcode; /* maximum code for lzw_nbits */ + unsigned short free_ent; /* next free entry in hash table */ + long nextdata; /* next bits of i/o */ + long nextbits; /* # of valid bits in lzw_nextdata */ - int rw_mode; /* preserve rw_mode from init */ + int rw_mode; /* preserve rw_mode from init */ } LZWBaseState; -#define lzw_nbits base.nbits -#define lzw_maxcode base.maxcode -#define lzw_free_ent base.free_ent -#define lzw_nextdata base.nextdata -#define lzw_nextbits base.nextbits +#define lzw_nbits base.nbits +#define lzw_maxcode base.maxcode +#define lzw_free_ent base.free_ent +#define lzw_nextdata base.nextdata +#define lzw_nextbits base.nextbits /* * Encoding-specific state. @@ -125,44 +125,44 @@ typedef struct code_ent { unsigned char firstchar; /* first token of string */ } code_t; -typedef int (*decodeFunc)(TIFF*, tidata_t, tsize_t, tsample_t); +typedef int (*decodeFunc)(TIFF*, uint8*, tmsize_t, uint16); typedef struct { LZWBaseState base; /* Decoding specific data */ - long dec_nbitsmask; /* lzw_nbits 1 bits, right adjusted */ - long dec_restart; /* restart count */ + long dec_nbitsmask; /* lzw_nbits 1 bits, right adjusted */ + long dec_restart; /* restart count */ #ifdef LZW_CHECKEOS - long dec_bitsleft; /* available bits in raw data */ + uint64 dec_bitsleft; /* available bits in raw data */ #endif decodeFunc dec_decode; /* regular or backwards compatible */ - code_t* dec_codep; /* current recognized code */ - code_t* dec_oldcodep; /* previously recognized code */ - code_t* dec_free_entp; /* next free entry */ - code_t* dec_maxcodep; /* max available entry */ - code_t* dec_codetab; /* kept separate for small machines */ + code_t* dec_codep; /* current recognized code */ + code_t* dec_oldcodep; /* previously recognized code */ + code_t* dec_free_entp; /* next free entry */ + code_t* dec_maxcodep; /* max available entry */ + code_t* dec_codetab; /* kept separate for small machines */ /* Encoding specific data */ - int enc_oldcode; /* last code encountered */ - long enc_checkpoint; /* point at which to clear table */ + int enc_oldcode; /* last code encountered */ + long enc_checkpoint; /* point at which to clear table */ #define CHECK_GAP 10000 /* enc_ratio check interval */ - long enc_ratio; /* current compression ratio */ - long enc_incount; /* (input) data bytes encoded */ - long enc_outcount; /* encoded (output) bytes */ - tidata_t enc_rawlimit; /* bound on tif_rawdata buffer */ - hash_t* enc_hashtab; /* kept separate for small machines */ + long enc_ratio; /* current compression ratio */ + long enc_incount; /* (input) data bytes encoded */ + long enc_outcount; /* encoded (output) bytes */ + uint8* enc_rawlimit; /* bound on tif_rawdata buffer */ + hash_t* enc_hashtab; /* kept separate for small machines */ } LZWCodecState; -#define LZWState(tif) ((LZWBaseState*) (tif)->tif_data) -#define DecoderState(tif) ((LZWCodecState*) LZWState(tif)) -#define EncoderState(tif) ((LZWCodecState*) LZWState(tif)) +#define LZWState(tif) ((LZWBaseState*) (tif)->tif_data) +#define DecoderState(tif) ((LZWCodecState*) LZWState(tif)) +#define EncoderState(tif) ((LZWCodecState*) LZWState(tif)) -static int LZWDecode(TIFF*, tidata_t, tsize_t, tsample_t); +static int LZWDecode(TIFF* tif, uint8* op0, tmsize_t occ0, uint16 s); #ifdef LZW_COMPAT -static int LZWDecodeCompat(TIFF*, tidata_t, tsize_t, tsample_t); +static int LZWDecodeCompat(TIFF* tif, uint8* op0, tmsize_t occ0, uint16 s); #endif -static void cl_hash(LZWCodecState*); +static void cl_hash(LZWCodecState*); /* * LZW Decoder. @@ -174,8 +174,8 @@ static void cl_hash(LZWCodecState*); * strip is suppose to be terminated with CODE_EOI. */ #define NextCode(_tif, _sp, _bp, _code, _get) { \ - if ((_sp)->dec_bitsleft < nbits) { \ - TIFFWarningExt(_tif->tif_clientdata, _tif->tif_name, \ + if ((_sp)->dec_bitsleft < (uint64)nbits) { \ + TIFFWarningExt(_tif->tif_clientdata, module, \ "LZWDecode: Strip %d not terminated with EOI code", \ _tif->tif_curstrip); \ _code = CODE_EOI; \ @@ -189,36 +189,43 @@ static void cl_hash(LZWCodecState*); #endif static int +LZWFixupTags(TIFF* tif) +{ + (void) tif; + return (1); +} + +static int LZWSetupDecode(TIFF* tif) { + static const char module[] = "LZWSetupDecode"; LZWCodecState* sp = DecoderState(tif); - static const char module[] = " LZWSetupDecode"; int code; - if( sp == NULL ) - { - /* - * Allocate state block so tag methods have storage to record - * values. - */ - tif->tif_data = (tidata_t) _TIFFmalloc(sizeof(LZWCodecState)); - if (tif->tif_data == NULL) - { - TIFFErrorExt(tif->tif_clientdata, "LZWPreDecode", "No space for LZW state block"); - return (0); - } - - DecoderState(tif)->dec_codetab = NULL; - DecoderState(tif)->dec_decode = NULL; - - /* - * Setup predictor setup. - */ - (void) TIFFPredictorInit(tif); - - sp = DecoderState(tif); - } - + if( sp == NULL ) + { + /* + * Allocate state block so tag methods have storage to record + * values. + */ + tif->tif_data = (uint8*) _TIFFmalloc(sizeof(LZWCodecState)); + if (tif->tif_data == NULL) + { + TIFFErrorExt(tif->tif_clientdata, module, "No space for LZW state block"); + return (0); + } + + DecoderState(tif)->dec_codetab = NULL; + DecoderState(tif)->dec_decode = NULL; + + /* + * Setup predictor setup. + */ + (void) TIFFPredictorInit(tif); + + sp = DecoderState(tif); + } + assert(sp != NULL); if (sp->dec_codetab == NULL) { @@ -231,13 +238,13 @@ LZWSetupDecode(TIFF* tif) /* * Pre-load the table. */ - code = 255; - do { - sp->dec_codetab[code].value = code; - sp->dec_codetab[code].firstchar = code; - sp->dec_codetab[code].length = 1; - sp->dec_codetab[code].next = NULL; - } while (code--); + code = 255; + do { + sp->dec_codetab[code].value = code; + sp->dec_codetab[code].firstchar = code; + sp->dec_codetab[code].length = 1; + sp->dec_codetab[code].next = NULL; + } while (code--); /* * Zero-out the unused entries */ @@ -251,13 +258,14 @@ LZWSetupDecode(TIFF* tif) * Setup state for decoding a strip. */ static int -LZWPreDecode(TIFF* tif, tsample_t s) +LZWPreDecode(TIFF* tif, uint16 s) { + static const char module[] = "LZWPreDecode"; LZWCodecState *sp = DecoderState(tif); (void) s; assert(sp != NULL); - if( sp->dec_codetab == NULL ) + if( sp->dec_codetab == NULL ) { tif->tif_setupdecode( tif ); } @@ -268,7 +276,7 @@ LZWPreDecode(TIFF* tif, tsample_t s) if (tif->tif_rawdata[0] == 0 && (tif->tif_rawdata[1] & 0x1)) { #ifdef LZW_COMPAT if (!sp->dec_decode) { - TIFFWarningExt(tif->tif_clientdata, tif->tif_name, + TIFFWarningExt(tif->tif_clientdata, module, "Old-style LZW codes, convert file"); /* * Override default decoding methods with @@ -291,7 +299,7 @@ LZWPreDecode(TIFF* tif, tsample_t s) sp->lzw_maxcode = MAXCODE(BITS_MIN); #else /* !LZW_COMPAT */ if (!sp->dec_decode) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, + TIFFErrorExt(tif->tif_clientdata, module, "Old-style LZW codes not supported"); sp->dec_decode = LZWDecode; } @@ -308,7 +316,7 @@ LZWPreDecode(TIFF* tif, tsample_t s) sp->dec_restart = 0; sp->dec_nbitsmask = MAXCODE(BITS_MIN); #ifdef LZW_CHECKEOS - sp->dec_bitsleft = tif->tif_rawcc << 3; + sp->dec_bitsleft = ((uint64)tif->tif_rawcc) << 3; #endif sp->dec_free_entp = sp->dec_codetab + CODE_FIRST; /* @@ -339,16 +347,17 @@ LZWPreDecode(TIFF* tif, tsample_t s) } static void -codeLoop(TIFF* tif) +codeLoop(TIFF* tif, const char* module) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "LZWDecode: Bogus encoding, loop in the code table; scanline %d", + TIFFErrorExt(tif->tif_clientdata, module, + "Bogus encoding, loop in the code table; scanline %d", tif->tif_row); } static int -LZWDecode(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) +LZWDecode(TIFF* tif, uint8* op0, tmsize_t occ0, uint16 s) { + static const char module[] = "LZWDecode"; LZWCodecState *sp = DecoderState(tif); char *op = (char*) op0; long occ = (long) occ0; @@ -362,6 +371,12 @@ LZWDecode(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) (void) s; assert(sp != NULL); assert(sp->dec_codetab != NULL); + + /* + Fail if value does not fit in long. + */ + if ((tmsize_t) occ != occ0) + return (0); /* * Restart interrupted output operation. */ @@ -428,7 +443,7 @@ LZWDecode(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) NextCode(tif, sp, bp, code, GetNextCode); if (code == CODE_EOI) break; - if (code == CODE_CLEAR) { + if (code >= CODE_CLEAR) { TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "LZWDecode: Corrupted LZW table at scanline %d", tif->tif_row); @@ -441,22 +456,22 @@ LZWDecode(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) codep = sp->dec_codetab + code; /* - * Add the new entry to the code table. - */ + * Add the new entry to the code table. + */ if (free_entp < &sp->dec_codetab[0] || - free_entp >= &sp->dec_codetab[CSIZE]) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "LZWDecode: Corrupted LZW table at scanline %d", - tif->tif_row); + free_entp >= &sp->dec_codetab[CSIZE]) { + TIFFErrorExt(tif->tif_clientdata, module, + "Corrupted LZW table at scanline %d", + tif->tif_row); return (0); } free_entp->next = oldcodep; if (free_entp->next < &sp->dec_codetab[0] || - free_entp->next >= &sp->dec_codetab[CSIZE]) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "LZWDecode: Corrupted LZW table at scanline %d", - tif->tif_row); + free_entp->next >= &sp->dec_codetab[CSIZE]) { + TIFFErrorExt(tif->tif_clientdata, module, + "Corrupted LZW table at scanline %d", + tif->tif_row); return (0); } free_entp->firstchar = free_entp->next->firstchar; @@ -472,15 +487,15 @@ LZWDecode(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) oldcodep = codep; if (code >= 256) { /* - * Code maps to a string, copy string + * Code maps to a string, copy string * value to output (written in reverse). - */ + */ if(codep->length == 0) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "LZWDecode: Wrong length of decoded string: " - "data probably corrupted at scanline %d", - tif->tif_row); - return (0); + TIFFErrorExt(tif->tif_clientdata, module, + "Wrong length of decoded string: " + "data probably corrupted at scanline %d", + tif->tif_row); + return (0); } if (codep->length > occ) { /* @@ -494,14 +509,14 @@ LZWDecode(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) codep = codep->next; } while (codep && codep->length > occ); if (codep) { - sp->dec_restart = occ; + sp->dec_restart = (long)occ; tp = op + occ; do { *--tp = codep->value; codep = codep->next; } while (--occ && codep); if (codep) - codeLoop(tif); + codeLoop(tif, module); } break; } @@ -515,15 +530,16 @@ LZWDecode(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) *tp = t; } while (codep && tp > op); if (codep) { - codeLoop(tif); + codeLoop(tif, module); break; } + assert(occ >= len); op += len, occ -= len; } else *op++ = (char)code, occ--; } - tif->tif_rawcp = (tidata_t) bp; + tif->tif_rawcp = (uint8*) bp; sp->lzw_nbits = (unsigned short) nbits; sp->lzw_nextdata = nextdata; sp->lzw_nextbits = nextbits; @@ -533,9 +549,15 @@ LZWDecode(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) sp->dec_maxcodep = maxcodep; if (occ > 0) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "LZWDecode: Not enough data at scanline %d (short %ld bytes)", - tif->tif_row, occ); +#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) + TIFFErrorExt(tif->tif_clientdata, module, + "Not enough data at scanline %d (short %I64d bytes)", + tif->tif_row, (unsigned __int64) occ); +#else + TIFFErrorExt(tif->tif_clientdata, module, + "Not enough data at scanline %d (short %llu bytes)", + tif->tif_row, (unsigned long long) occ); +#endif return (0); } return (1); @@ -558,8 +580,9 @@ LZWDecode(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) } static int -LZWDecodeCompat(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) +LZWDecodeCompat(TIFF* tif, uint8* op0, tmsize_t occ0, uint16 s) { + static const char module[] = "LZWDecodeCompat"; LZWCodecState *sp = DecoderState(tif); char *op = (char*) op0; long occ = (long) occ0; @@ -571,6 +594,13 @@ LZWDecodeCompat(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) (void) s; assert(sp != NULL); + + /* + Fail if value does not fit in long. + */ + if ((tmsize_t) occ != occ0) + return (0); + /* * Restart interrupted output operation. */ @@ -632,7 +662,7 @@ LZWDecodeCompat(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) NextCode(tif, sp, bp, code, GetNextCodeCompat); if (code == CODE_EOI) break; - if (code == CODE_CLEAR) { + if (code >= CODE_CLEAR) { TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "LZWDecode: Corrupted LZW table at scanline %d", tif->tif_row); @@ -645,22 +675,20 @@ LZWDecodeCompat(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) codep = sp->dec_codetab + code; /* - * Add the new entry to the code table. - */ + * Add the new entry to the code table. + */ if (free_entp < &sp->dec_codetab[0] || - free_entp >= &sp->dec_codetab[CSIZE]) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "LZWDecodeCompat: Corrupted LZW table at scanline %d", - tif->tif_row); + free_entp >= &sp->dec_codetab[CSIZE]) { + TIFFErrorExt(tif->tif_clientdata, module, + "Corrupted LZW table at scanline %d", tif->tif_row); return (0); } free_entp->next = oldcodep; if (free_entp->next < &sp->dec_codetab[0] || - free_entp->next >= &sp->dec_codetab[CSIZE]) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "LZWDecodeCompat: Corrupted LZW table at scanline %d", - tif->tif_row); + free_entp->next >= &sp->dec_codetab[CSIZE]) { + TIFFErrorExt(tif->tif_clientdata, module, + "Corrupted LZW table at scanline %d", tif->tif_row); return (0); } free_entp->firstchar = free_entp->next->firstchar; @@ -675,17 +703,16 @@ LZWDecodeCompat(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) } oldcodep = codep; if (code >= 256) { - char *op_orig = op; /* - * Code maps to a string, copy string + * Code maps to a string, copy string * value to output (written in reverse). - */ + */ if(codep->length == 0) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "LZWDecodeCompat: Wrong length of decoded " - "string: data probably corrupted at scanline %d", - tif->tif_row); - return (0); + TIFFErrorExt(tif->tif_clientdata, module, + "Wrong length of decoded " + "string: data probably corrupted at scanline %d", + tif->tif_row); + return (0); } if (codep->length > occ) { /* @@ -706,16 +733,17 @@ LZWDecodeCompat(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) } while (--occ); break; } + assert(occ >= codep->length); op += codep->length, occ -= codep->length; tp = op; do { *--tp = codep->value; - } while( (codep = codep->next) != NULL && tp > op_orig); + } while( (codep = codep->next) != NULL ); } else *op++ = code, occ--; } - tif->tif_rawcp = (tidata_t) bp; + tif->tif_rawcp = (uint8*) bp; sp->lzw_nbits = nbits; sp->lzw_nextdata = nextdata; sp->lzw_nextbits = nextbits; @@ -725,9 +753,15 @@ LZWDecodeCompat(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) sp->dec_maxcodep = maxcodep; if (occ > 0) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "LZWDecodeCompat: Not enough data at scanline %d (short %ld bytes)", - tif->tif_row, occ); +#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) + TIFFErrorExt(tif->tif_clientdata, module, + "Not enough data at scanline %d (short %I64d bytes)", + tif->tif_row, (unsigned __int64) occ); +#else + TIFFErrorExt(tif->tif_clientdata, module, + "Not enough data at scanline %d (short %llu bytes)", + tif->tif_row, (unsigned long long) occ); +#endif return (0); } return (1); @@ -741,13 +775,14 @@ LZWDecodeCompat(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) static int LZWSetupEncode(TIFF* tif) { - LZWCodecState* sp = EncoderState(tif); static const char module[] = "LZWSetupEncode"; + LZWCodecState* sp = EncoderState(tif); assert(sp != NULL); sp->enc_hashtab = (hash_t*) _TIFFmalloc(HSIZE*sizeof (hash_t)); if (sp->enc_hashtab == NULL) { - TIFFErrorExt(tif->tif_clientdata, module, "No space for LZW hash table"); + TIFFErrorExt(tif->tif_clientdata, module, + "No space for LZW hash table"); return (0); } return (1); @@ -757,14 +792,14 @@ LZWSetupEncode(TIFF* tif) * Reset encoding state at the start of a strip. */ static int -LZWPreEncode(TIFF* tif, tsample_t s) +LZWPreEncode(TIFF* tif, uint16 s) { LZWCodecState *sp = EncoderState(tif); (void) s; assert(sp != NULL); - - if( sp->enc_hashtab == NULL ) + + if( sp->enc_hashtab == NULL ) { tif->tif_setupencode( tif ); } @@ -822,7 +857,7 @@ LZWPreEncode(TIFF* tif, tsample_t s) * for the decoder. */ static int -LZWEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) +LZWEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s) { register LZWCodecState *sp = EncoderState(tif); register long fcode; @@ -833,7 +868,8 @@ LZWEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) long incount, outcount, checkpoint; long nextdata, nextbits; int free_ent, maxcode, nbits; - tidata_t op, limit; + uint8* op; + uint8* limit; (void) s; if (sp == NULL) @@ -912,7 +948,7 @@ LZWEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) * are at least 4 bytes free--room for 2 codes. */ if (op > limit) { - tif->tif_rawcc = (tsize_t)(op - tif->tif_rawdata); + tif->tif_rawcc = (tmsize_t)(op - tif->tif_rawdata); TIFFFlushData1(tif); op = tif->tif_rawdata; } @@ -990,14 +1026,14 @@ static int LZWPostEncode(TIFF* tif) { register LZWCodecState *sp = EncoderState(tif); - tidata_t op = tif->tif_rawcp; + uint8* op = tif->tif_rawcp; long nextbits = sp->lzw_nextbits; long nextdata = sp->lzw_nextdata; long outcount = sp->enc_outcount; int nbits = sp->lzw_nbits; if (op > sp->enc_rawlimit) { - tif->tif_rawcc = (tsize_t)(op - tif->tif_rawdata); + tif->tif_rawcc = (tmsize_t)(op - tif->tif_rawdata); TIFFFlushData1(tif); op = tif->tif_rawdata; } @@ -1008,7 +1044,7 @@ LZWPostEncode(TIFF* tif) PutNextCode(op, CODE_EOI); if (nextbits > 0) *op++ = (unsigned char)(nextdata << (8-nextbits)); - tif->tif_rawcc = (tsize_t)(op - tif->tif_rawdata); + tif->tif_rawcc = (tmsize_t)(op - tif->tif_rawdata); return (1); } @@ -1021,7 +1057,7 @@ cl_hash(LZWCodecState* sp) register hash_t *hp = &sp->enc_hashtab[HSIZE-1]; register long i = HSIZE-8; - do { + do { i -= 8; hp[-7].hash = -1; hp[-6].hash = -1; @@ -1033,7 +1069,7 @@ cl_hash(LZWCodecState* sp) hp[ 0].hash = -1; hp -= 8; } while (i >= 0); - for (i += 8; i > 0; i--, hp--) + for (i += 8; i > 0; i--, hp--) hp->hash = -1; } @@ -1059,11 +1095,12 @@ LZWCleanup(TIFF* tif) int TIFFInitLZW(TIFF* tif, int scheme) { + static const char module[] = "TIFFInitLZW"; assert(scheme == COMPRESSION_LZW); /* * Allocate state block so tag methods have storage to record values. */ - tif->tif_data = (tidata_t) _TIFFmalloc(sizeof (LZWCodecState)); + tif->tif_data = (uint8*) _TIFFmalloc(sizeof (LZWCodecState)); if (tif->tif_data == NULL) goto bad; DecoderState(tif)->dec_codetab = NULL; @@ -1074,6 +1111,7 @@ TIFFInitLZW(TIFF* tif, int scheme) /* * Install codec methods. */ + tif->tif_fixuptags = LZWFixupTags; tif->tif_setupdecode = LZWSetupDecode; tif->tif_predecode = LZWPreDecode; tif->tif_decoderow = LZWDecode; @@ -1092,7 +1130,7 @@ TIFFInitLZW(TIFF* tif, int scheme) (void) TIFFPredictorInit(tif); return (1); bad: - TIFFErrorExt(tif->tif_clientdata, "TIFFInitLZW", + TIFFErrorExt(tif->tif_clientdata, module, "No space for LZW state block"); return (0); } @@ -1120,3 +1158,10 @@ bad: #endif /* LZW_SUPPORT */ /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_msdos.c b/src/3rdparty/libtiff/libtiff/tif_msdos.c deleted file mode 100644 index 72cd39e..0000000 --- a/src/3rdparty/libtiff/libtiff/tif_msdos.c +++ /dev/null @@ -1,186 +0,0 @@ -/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_msdos.c,v 1.3 2006/07/25 18:26:33 fwarmerdam Exp $ */ - -/* - * Copyright (c) 1988-1997 Sam Leffler - * Copyright (c) 1991-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. - */ - -/* - * TIFF Library MSDOS-specific Routines. - */ -#if defined(__WATCOMC__) || defined(__BORLANDC__) || defined(_MSC_VER) -#include <io.h> /* for open, close, etc. function prototypes */ -#include <stdio.h> -#endif -#include "tiffiop.h" - -static tsize_t -_tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size) -{ - return (read((int) fd, buf, size)); -} - -static tsize_t -_tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size) -{ - return (write((int) fd, buf, size)); -} - -static toff_t -_tiffSeekProc(thandle_t fd, toff_t off, int whence) -{ - return (lseek((int) fd, (off_t) off, whence)); -} - -static int -_tiffCloseProc(thandle_t fd) -{ - return (close((int) fd)); -} - -#include <sys/stat.h> - -static toff_t -_tiffSizeProc(thandle_t fd) -{ - struct stat sb; - return (fstat((int) fd, &sb) < 0 ? 0 : sb.st_size); -} - -static int -_tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) -{ - return (0); -} - -static void -_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size) -{ -} - -/* - * Open a TIFF file descriptor for read/writing. - */ -TIFF* -TIFFFdOpen(int fd, const char* name, const char* mode) -{ - TIFF* tif; - - tif = TIFFClientOpen(name, mode, - (void*) fd, - _tiffReadProc, _tiffWriteProc, _tiffSeekProc, _tiffCloseProc, - _tiffSizeProc, _tiffMapProc, _tiffUnmapProc); - if (tif) - tif->tif_fd = fd; - return (tif); -} - -/* - * Open a TIFF file for read/writing. - */ -TIFF* -TIFFOpen(const char* name, const char* mode) -{ - static const char module[] = "TIFFOpen"; - int m, fd; - TIFF *ret; - - m = _TIFFgetMode(mode, module); - if (m == -1) - return ((TIFF*)0); - fd = open(name, m|O_BINARY, 0666); - if (fd < 0) { - TIFFErrorExt(0, module, "%s: Cannot open", name); - return ((TIFF*)0); - } - return (TIFFFdOpen(fd, name, mode)); - - ret = TIFFFdOpen(fd, name, mode); - - if (ret == NULL) close(fd); - - return ret; -} - -#ifdef __GNUC__ -extern char* malloc(); -extern char* realloc(); -#else -#include <malloc.h> -#endif - -tdata_t -_TIFFmalloc(tsize_t s) -{ - return (malloc((size_t) s)); -} - -void -_TIFFfree(tdata_t p) -{ - free(p); -} - -tdata_t -_TIFFrealloc(tdata_t p, tsize_t s) -{ - return (realloc(p, (size_t) s)); -} - -void -_TIFFmemset(tdata_t p, int v, tsize_t c) -{ - memset(p, v, (size_t) c); -} - -void -_TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c) -{ - memcpy(d, s, (size_t) c); -} - -int -_TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c) -{ - return (memcmp(p1, p2, (size_t) c)); -} - -static void -msdosWarningHandler(const char* module, const char* fmt, va_list ap) -{ - if (module != NULL) - fprintf(stderr, "%s: ", module); - fprintf(stderr, "Warning, "); - vfprintf(stderr, fmt, ap); - fprintf(stderr, ".\n"); -} -TIFFErrorHandler _TIFFwarningHandler = msdosWarningHandler; - -static void -msdosErrorHandler(const char* module, const char* fmt, va_list ap) -{ - if (module != NULL) - fprintf(stderr, "%s: ", module); - vfprintf(stderr, fmt, ap); - fprintf(stderr, ".\n"); -} -TIFFErrorHandler _TIFFerrorHandler = msdosErrorHandler; diff --git a/src/3rdparty/libtiff/libtiff/tif_next.c b/src/3rdparty/libtiff/libtiff/tif_next.c index 0e1842d..524e127 100644 --- a/src/3rdparty/libtiff/libtiff/tif_next.c +++ b/src/3rdparty/libtiff/libtiff/tif_next.c @@ -1,4 +1,4 @@ -/* $Id: tif_next.c,v 1.8 2006/10/12 15:00:49 dron Exp $ */ +/* $Id: tif_next.c,v 1.13 2010-03-10 18:56:48 bfriesen Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler @@ -46,12 +46,13 @@ #define WHITE ((1<<2)-1) static int -NeXTDecode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s) +NeXTDecode(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s) { + static const char module[] = "NeXTDecode"; unsigned char *bp, *op; - tsize_t cc; - tidata_t row; - tsize_t scanline, n; + tmsize_t cc; + uint8* row; + tmsize_t scanline, n; (void) s; /* @@ -59,12 +60,17 @@ NeXTDecode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s) * white (we assume a PhotometricInterpretation * of ``min-is-black''). */ - for (op = buf, cc = occ; cc-- > 0;) + for (op = (unsigned char*) buf, cc = occ; cc-- > 0;) *op++ = 0xff; bp = (unsigned char *)tif->tif_rawcp; cc = tif->tif_rawcc; scanline = tif->tif_scanlinesize; + if (occ % scanline) + { + TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read"); + return (0); + } for (row = buf; occ > 0; occ -= scanline, row += scanline) { n = *bp++, cc--; switch (n) { @@ -79,7 +85,7 @@ NeXTDecode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s) cc -= scanline; break; case LITERALSPAN: { - tsize_t off; + tmsize_t off; /* * The scanline has a literal span that begins at some * offset. @@ -105,7 +111,7 @@ NeXTDecode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s) */ op = row; for (;;) { - grey = (n>>6) & 0x3; + grey = (uint32)((n>>6) & 0x3); n &= 0x3f; /* * Ensure the run does not exceed the scanline @@ -124,11 +130,11 @@ NeXTDecode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s) } } } - tif->tif_rawcp = (tidata_t) bp; + tif->tif_rawcp = (uint8*) bp; tif->tif_rawcc = cc; return (1); bad: - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "NeXTDecode: Not enough data for scanline %ld", + TIFFErrorExt(tif->tif_clientdata, module, "Not enough data for scanline %ld", (long) tif->tif_row); return (0); } @@ -137,11 +143,18 @@ int TIFFInitNeXT(TIFF* tif, int scheme) { (void) scheme; - tif->tif_decoderow = NeXTDecode; - tif->tif_decodestrip = NeXTDecode; + tif->tif_decoderow = NeXTDecode; + tif->tif_decodestrip = NeXTDecode; tif->tif_decodetile = NeXTDecode; return (1); } #endif /* NEXT_SUPPORT */ /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_ojpeg.c b/src/3rdparty/libtiff/libtiff/tif_ojpeg.c index 9d1e804..6ea3c38 100644 --- a/src/3rdparty/libtiff/libtiff/tif_ojpeg.c +++ b/src/3rdparty/libtiff/libtiff/tif_ojpeg.c @@ -1,4 +1,4 @@ -/* $Id: tif_ojpeg.c,v 1.24.2.4 2009-09-03 20:45:10 bfriesen Exp $ */ +/* $Id: tif_ojpeg.c,v 1.56 2012-05-24 03:15:18 fwarmerdam Exp $ */ /* WARNING: The type of JPEG encapsulation defined by the TIFF Version 6.0 specification is now totally obsolete and deprecated for new applications and @@ -120,6 +120,8 @@ session. */ +#define WIN32_LEAN_AND_MEAN +#define VC_EXTRALEAN #include "tiffiop.h" #ifdef OJPEG_SUPPORT @@ -146,7 +148,7 @@ * absolutely no effect. That is why most people insist the EGYPTIANWALK is a bit silly. */ -/* #define LIBJPEG_ENCAP_EXTERNAL */ +/* define LIBJPEG_ENCAP_EXTERNAL */ #define SETJMP(jbuf) setjmp(jbuf) #define LONGJMP(jbuf,code) longjmp(jbuf,code) #define JMP_BUF jmp_buf @@ -173,22 +175,45 @@ #define FIELD_OJPEG_JPEGACTABLES (FIELD_CODEC+4) #define FIELD_OJPEG_JPEGPROC (FIELD_CODEC+5) #define FIELD_OJPEG_JPEGRESTARTINTERVAL (FIELD_CODEC+6) -#define FIELD_OJPEG_COUNT 7 - -static const TIFFFieldInfo ojpeg_field_info[] = { - {TIFFTAG_JPEGIFOFFSET,1,1,TIFF_LONG,FIELD_OJPEG_JPEGINTERCHANGEFORMAT,TRUE,FALSE,"JpegInterchangeFormat"}, - {TIFFTAG_JPEGIFBYTECOUNT,1,1,TIFF_LONG,FIELD_OJPEG_JPEGINTERCHANGEFORMATLENGTH,TRUE,FALSE,"JpegInterchangeFormatLength"}, - {TIFFTAG_JPEGQTABLES,TIFF_VARIABLE,TIFF_VARIABLE,TIFF_LONG,FIELD_OJPEG_JPEGQTABLES,FALSE,TRUE,"JpegQTables"}, - {TIFFTAG_JPEGDCTABLES,TIFF_VARIABLE,TIFF_VARIABLE,TIFF_LONG,FIELD_OJPEG_JPEGDCTABLES,FALSE,TRUE,"JpegDcTables"}, - {TIFFTAG_JPEGACTABLES,TIFF_VARIABLE,TIFF_VARIABLE,TIFF_LONG,FIELD_OJPEG_JPEGACTABLES,FALSE,TRUE,"JpegAcTables"}, - {TIFFTAG_JPEGPROC,1,1,TIFF_SHORT,FIELD_OJPEG_JPEGPROC,FALSE,FALSE,"JpegProc"}, - {TIFFTAG_JPEGRESTARTINTERVAL,1,1,TIFF_SHORT,FIELD_OJPEG_JPEGRESTARTINTERVAL,FALSE,FALSE,"JpegRestartInterval"}, + +static const TIFFField ojpegFields[] = { + {TIFFTAG_JPEGIFOFFSET,1,1,TIFF_LONG8,0,TIFF_SETGET_UINT64,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGINTERCHANGEFORMAT,TRUE,FALSE,"JpegInterchangeFormat",NULL}, + {TIFFTAG_JPEGIFBYTECOUNT,1,1,TIFF_LONG8,0,TIFF_SETGET_UINT64,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGINTERCHANGEFORMATLENGTH,TRUE,FALSE,"JpegInterchangeFormatLength",NULL}, + {TIFFTAG_JPEGQTABLES,TIFF_VARIABLE2,TIFF_VARIABLE2,TIFF_LONG8,0,TIFF_SETGET_C32_UINT64,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGQTABLES,FALSE,TRUE,"JpegQTables",NULL}, + {TIFFTAG_JPEGDCTABLES,TIFF_VARIABLE2,TIFF_VARIABLE2,TIFF_LONG8,0,TIFF_SETGET_C32_UINT64,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGDCTABLES,FALSE,TRUE,"JpegDcTables",NULL}, + {TIFFTAG_JPEGACTABLES,TIFF_VARIABLE2,TIFF_VARIABLE2,TIFF_LONG8,0,TIFF_SETGET_C32_UINT64,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGACTABLES,FALSE,TRUE,"JpegAcTables",NULL}, + {TIFFTAG_JPEGPROC,1,1,TIFF_SHORT,0,TIFF_SETGET_UINT16,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGPROC,FALSE,FALSE,"JpegProc",NULL}, + {TIFFTAG_JPEGRESTARTINTERVAL,1,1,TIFF_SHORT,0,TIFF_SETGET_UINT16,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGRESTARTINTERVAL,FALSE,FALSE,"JpegRestartInterval",NULL}, }; #ifndef LIBJPEG_ENCAP_EXTERNAL #include <setjmp.h> #endif +/* 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 conficting typedef given the headers which are included. +*/ +#if defined(__BORLANDC__) || defined(__MINGW32__) +# define XMD_H 1 +#endif + +/* 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 /* prevent jmorecfg.h from redefining it */ +#endif + #include "jpeglib.h" #include "jerror.h" @@ -224,7 +249,8 @@ typedef struct { #endif TIFFVGetMethod vgetparent; TIFFVSetMethod vsetparent; - toff_t file_size; + TIFFPrintMethod printdir; + uint64 file_size; uint32 image_width; uint32 image_length; uint32 strile_width; @@ -233,8 +259,8 @@ typedef struct { uint8 samples_per_pixel; uint8 plane_sample_offset; uint8 samples_per_pixel_per_plane; - toff_t jpeg_interchange_format; - toff_t jpeg_interchange_format_length; + uint64 jpeg_interchange_format; + uint64 jpeg_interchange_format_length; uint8 jpeg_proc; uint8 subsamplingcorrect; uint8 subsamplingcorrect_done; @@ -245,9 +271,9 @@ typedef struct { uint8 qtable_offset_count; uint8 dctable_offset_count; uint8 actable_offset_count; - toff_t qtable_offset[3]; - toff_t dctable_offset[3]; - toff_t actable_offset[3]; + uint64 qtable_offset[3]; + uint64 dctable_offset[3]; + uint64 actable_offset[3]; uint8* qtable[4]; uint8* dctable[4]; uint8* actable[4]; @@ -265,14 +291,14 @@ typedef struct { struct { uint8 log; OJPEGStateInBufferSource in_buffer_source; - tstrile_t in_buffer_next_strile; - toff_t in_buffer_file_pos; - toff_t in_buffer_file_togo; + uint32 in_buffer_next_strile; + uint64 in_buffer_file_pos; + uint64 in_buffer_file_togo; } sos_end[3]; uint8 readheader_done; uint8 writeheader_done; - tsample_t write_cursample; - tstrile_t write_curstrile; + uint16 write_cursample; + uint32 write_curstrile; uint8 libjpeg_session_active; uint8 libjpeg_jpeg_query_style; jpeg_error_mgr libjpeg_jpeg_error_mgr; @@ -297,11 +323,11 @@ typedef struct { uint32 bytes_per_line; /* if the codec outputs subsampled data, a 'line' in bytes_per_line */ uint32 lines_per_strile; /* and lines_per_strile means subsampling_ver desubsampled rows */ OJPEGStateInBufferSource in_buffer_source; - tstrile_t in_buffer_next_strile; - tstrile_t in_buffer_strile_count; - toff_t in_buffer_file_pos; + uint32 in_buffer_next_strile; + uint32 in_buffer_strile_count; + uint64 in_buffer_file_pos; uint8 in_buffer_file_pos_log; - toff_t in_buffer_file_togo; + uint64 in_buffer_file_togo; uint16 in_buffer_togo; uint8* in_buffer_cur; uint8 in_buffer[OJPEG_BUFFER]; @@ -310,27 +336,28 @@ typedef struct { uint8* skip_buffer; } OJPEGState; -static int OJPEGVGetField(TIFF* tif, ttag_t tag, va_list ap); -static int OJPEGVSetField(TIFF* tif, ttag_t tag, va_list ap); +static int OJPEGVGetField(TIFF* tif, uint32 tag, va_list ap); +static int OJPEGVSetField(TIFF* tif, uint32 tag, va_list ap); static void OJPEGPrintDir(TIFF* tif, FILE* fd, long flags); +static int OJPEGFixupTags(TIFF* tif); static int OJPEGSetupDecode(TIFF* tif); -static int OJPEGPreDecode(TIFF* tif, tsample_t s); +static int OJPEGPreDecode(TIFF* tif, uint16 s); static int OJPEGPreDecodeSkipRaw(TIFF* tif); static int OJPEGPreDecodeSkipScanlines(TIFF* tif); -static int OJPEGDecode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s); -static int OJPEGDecodeRaw(TIFF* tif, tidata_t buf, tsize_t cc); -static int OJPEGDecodeScanlines(TIFF* tif, tidata_t buf, tsize_t cc); -static void OJPEGPostDecode(TIFF* tif, tidata_t buf, tsize_t cc); +static int OJPEGDecode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s); +static int OJPEGDecodeRaw(TIFF* tif, uint8* buf, tmsize_t cc); +static int OJPEGDecodeScanlines(TIFF* tif, uint8* buf, tmsize_t cc); +static void OJPEGPostDecode(TIFF* tif, uint8* buf, tmsize_t cc); static int OJPEGSetupEncode(TIFF* tif); -static int OJPEGPreEncode(TIFF* tif, tsample_t s); -static int OJPEGEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s); +static int OJPEGPreEncode(TIFF* tif, uint16 s); +static int OJPEGEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s); static int OJPEGPostEncode(TIFF* tif); static void OJPEGCleanup(TIFF* tif); static void OJPEGSubsamplingCorrect(TIFF* tif); static int OJPEGReadHeaderInfo(TIFF* tif); -static int OJPEGReadSecondarySos(TIFF* tif, tsample_t s); +static int OJPEGReadSecondarySos(TIFF* tif, uint16 s); static int OJPEGWriteHeaderInfo(TIFF* tif); static void OJPEGLibjpegSessionAbort(TIFF* tif); @@ -399,9 +426,9 @@ TIFFInitOJPEG(TIFF* tif, int scheme) /* * Merge codec-specific tag information. */ - if (!_TIFFMergeFieldInfo(tif,ojpeg_field_info,FIELD_OJPEG_COUNT)) { + if (!_TIFFMergeFields(tif, ojpegFields, TIFFArrayCount(ojpegFields))) { TIFFErrorExt(tif->tif_clientdata, module, - "Merging Old JPEG codec-specific tags failed"); + "Merging Old JPEG codec-specific tags failed"); return 0; } @@ -419,25 +446,27 @@ TIFFInitOJPEG(TIFF* tif, int scheme) sp->subsampling_ver=2; TIFFSetField(tif,TIFFTAG_YCBCRSUBSAMPLING,2,2); /* tif codec methods */ + tif->tif_fixuptags=OJPEGFixupTags; tif->tif_setupdecode=OJPEGSetupDecode; tif->tif_predecode=OJPEGPreDecode; - tif->tif_postdecode=OJPEGPostDecode; - tif->tif_decoderow=OJPEGDecode; - tif->tif_decodestrip=OJPEGDecode; - tif->tif_decodetile=OJPEGDecode; + tif->tif_postdecode=OJPEGPostDecode; + tif->tif_decoderow=OJPEGDecode; + tif->tif_decodestrip=OJPEGDecode; + tif->tif_decodetile=OJPEGDecode; tif->tif_setupencode=OJPEGSetupEncode; tif->tif_preencode=OJPEGPreEncode; tif->tif_postencode=OJPEGPostEncode; - tif->tif_encoderow=OJPEGEncode; - tif->tif_encodestrip=OJPEGEncode; - tif->tif_encodetile=OJPEGEncode; + tif->tif_encoderow=OJPEGEncode; + tif->tif_encodestrip=OJPEGEncode; + tif->tif_encodetile=OJPEGEncode; tif->tif_cleanup=OJPEGCleanup; - tif->tif_data=(tidata_t)sp; + tif->tif_data=(uint8*)sp; /* tif tag methods */ sp->vgetparent=tif->tif_tagmethods.vgetfield; tif->tif_tagmethods.vgetfield=OJPEGVGetField; sp->vsetparent=tif->tif_tagmethods.vsetfield; tif->tif_tagmethods.vsetfield=OJPEGVSetField; + sp->printdir=tif->tif_tagmethods.printdir; tif->tif_tagmethods.printdir=OJPEGPrintDir; /* Some OJPEG files don't have strip or tile offsets or bytecounts tags. Some others do, but have totally meaningless or corrupt values @@ -450,16 +479,16 @@ TIFFInitOJPEG(TIFF* tif, int scheme) } static int -OJPEGVGetField(TIFF* tif, ttag_t tag, va_list ap) +OJPEGVGetField(TIFF* tif, uint32 tag, va_list ap) { OJPEGState* sp=(OJPEGState*)tif->tif_data; switch(tag) { case TIFFTAG_JPEGIFOFFSET: - *va_arg(ap,uint32*)=(uint32)sp->jpeg_interchange_format; + *va_arg(ap,uint64*)=(uint64)sp->jpeg_interchange_format; break; case TIFFTAG_JPEGIFBYTECOUNT: - *va_arg(ap,uint32*)=(uint32)sp->jpeg_interchange_format_length; + *va_arg(ap,uint64*)=(uint64)sp->jpeg_interchange_format_length; break; case TIFFTAG_YCBCRSUBSAMPLING: if (sp->subsamplingcorrect_done==0) @@ -469,11 +498,11 @@ OJPEGVGetField(TIFF* tif, ttag_t tag, va_list ap) break; case TIFFTAG_JPEGQTABLES: *va_arg(ap,uint32*)=(uint32)sp->qtable_offset_count; - *va_arg(ap,void**)=(void*)sp->qtable_offset; + *va_arg(ap,void**)=(void*)sp->qtable_offset; break; case TIFFTAG_JPEGDCTABLES: *va_arg(ap,uint32*)=(uint32)sp->dctable_offset_count; - *va_arg(ap,void**)=(void*)sp->dctable_offset; + *va_arg(ap,void**)=(void*)sp->dctable_offset; break; case TIFFTAG_JPEGACTABLES: *va_arg(ap,uint32*)=(uint32)sp->actable_offset_count; @@ -492,30 +521,30 @@ OJPEGVGetField(TIFF* tif, ttag_t tag, va_list ap) } static int -OJPEGVSetField(TIFF* tif, ttag_t tag, va_list ap) +OJPEGVSetField(TIFF* tif, uint32 tag, va_list ap) { static const char module[]="OJPEGVSetField"; OJPEGState* sp=(OJPEGState*)tif->tif_data; uint32 ma; - uint32* mb; + uint64* mb; uint32 n; switch(tag) { case TIFFTAG_JPEGIFOFFSET: - sp->jpeg_interchange_format=(toff_t)va_arg(ap,uint32); + sp->jpeg_interchange_format=(uint64)va_arg(ap,uint64); break; case TIFFTAG_JPEGIFBYTECOUNT: - sp->jpeg_interchange_format_length=(toff_t)va_arg(ap,uint32); + sp->jpeg_interchange_format_length=(uint64)va_arg(ap,uint64); break; case TIFFTAG_YCBCRSUBSAMPLING: sp->subsampling_tag=1; - sp->subsampling_hor=(uint8)va_arg(ap,int); - sp->subsampling_ver=(uint8)va_arg(ap,int); + sp->subsampling_hor=(uint8)va_arg(ap,uint16_vap); + sp->subsampling_ver=(uint8)va_arg(ap,uint16_vap); tif->tif_dir.td_ycbcrsubsampling[0]=sp->subsampling_hor; tif->tif_dir.td_ycbcrsubsampling[1]=sp->subsampling_ver; break; case TIFFTAG_JPEGQTABLES: - ma=va_arg(ap,uint32); + ma=(uint32)va_arg(ap,uint32); if (ma!=0) { if (ma>3) @@ -524,13 +553,13 @@ OJPEGVSetField(TIFF* tif, ttag_t tag, va_list ap) return(0); } sp->qtable_offset_count=(uint8)ma; - mb=va_arg(ap,uint32*); + mb=(uint64*)va_arg(ap,uint64*); for (n=0; n<ma; n++) - sp->qtable_offset[n]=(toff_t)mb[n]; + sp->qtable_offset[n]=mb[n]; } break; case TIFFTAG_JPEGDCTABLES: - ma=va_arg(ap,uint32); + ma=(uint32)va_arg(ap,uint32); if (ma!=0) { if (ma>3) @@ -539,13 +568,13 @@ OJPEGVSetField(TIFF* tif, ttag_t tag, va_list ap) return(0); } sp->dctable_offset_count=(uint8)ma; - mb=va_arg(ap,uint32*); + mb=(uint64*)va_arg(ap,uint64*); for (n=0; n<ma; n++) - sp->dctable_offset[n]=(toff_t)mb[n]; + sp->dctable_offset[n]=mb[n]; } break; case TIFFTAG_JPEGACTABLES: - ma=va_arg(ap,uint32); + ma=(uint32)va_arg(ap,uint32); if (ma!=0) { if (ma>3) @@ -554,21 +583,21 @@ OJPEGVSetField(TIFF* tif, ttag_t tag, va_list ap) return(0); } sp->actable_offset_count=(uint8)ma; - mb=va_arg(ap,uint32*); + mb=(uint64*)va_arg(ap,uint64*); for (n=0; n<ma; n++) - sp->actable_offset[n]=(toff_t)mb[n]; + sp->actable_offset[n]=mb[n]; } break; case TIFFTAG_JPEGPROC: - sp->jpeg_proc=(uint8)va_arg(ap,uint32); + sp->jpeg_proc=(uint8)va_arg(ap,uint16_vap); break; case TIFFTAG_JPEGRESTARTINTERVAL: - sp->restart_interval=(uint16)va_arg(ap,uint32); + sp->restart_interval=(uint16)va_arg(ap,uint16_vap); break; default: return (*sp->vsetparent)(tif,tag,ap); } - TIFFSetFieldBit(tif,_TIFFFieldWithTag(tif,tag)->field_bit); + TIFFSetFieldBit(tif,TIFFFieldWithTag(tif,tag)->field_bit); tif->tif_flags|=TIFF_DIRTYDIRECT; return(1); } @@ -581,34 +610,43 @@ OJPEGPrintDir(TIFF* tif, FILE* fd, long flags) (void)flags; assert(sp!=NULL); if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGINTERCHANGEFORMAT)) - fprintf(fd," JpegInterchangeFormat: %lu\n",(unsigned long)sp->jpeg_interchange_format); + fprintf(fd," JpegInterchangeFormat: " TIFF_UINT64_FORMAT "\n",(TIFF_UINT64_T)sp->jpeg_interchange_format); if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGINTERCHANGEFORMATLENGTH)) - fprintf(fd," JpegInterchangeFormatLength: %lu\n",(unsigned long)sp->jpeg_interchange_format_length); + fprintf(fd," JpegInterchangeFormatLength: " TIFF_UINT64_FORMAT "\n",(TIFF_UINT64_T)sp->jpeg_interchange_format_length); if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGQTABLES)) { fprintf(fd," JpegQTables:"); for (m=0; m<sp->qtable_offset_count; m++) - fprintf(fd," %lu",(unsigned long)sp->qtable_offset[m]); + fprintf(fd," " TIFF_UINT64_FORMAT,(TIFF_UINT64_T)sp->qtable_offset[m]); fprintf(fd,"\n"); } if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGDCTABLES)) { fprintf(fd," JpegDcTables:"); for (m=0; m<sp->dctable_offset_count; m++) - fprintf(fd," %lu",(unsigned long)sp->dctable_offset[m]); + fprintf(fd," " TIFF_UINT64_FORMAT,(TIFF_UINT64_T)sp->dctable_offset[m]); fprintf(fd,"\n"); } if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGACTABLES)) { fprintf(fd," JpegAcTables:"); for (m=0; m<sp->actable_offset_count; m++) - fprintf(fd," %lu",(unsigned long)sp->actable_offset[m]); + fprintf(fd," " TIFF_UINT64_FORMAT,(TIFF_UINT64_T)sp->actable_offset[m]); fprintf(fd,"\n"); } if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGPROC)) fprintf(fd," JpegProc: %u\n",(unsigned int)sp->jpeg_proc); if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGRESTARTINTERVAL)) fprintf(fd," JpegRestartInterval: %u\n",(unsigned int)sp->restart_interval); + if (sp->printdir) + (*sp->printdir)(tif, fd, flags); +} + +static int +OJPEGFixupTags(TIFF* tif) +{ + (void) tif; + return(1); } static int @@ -620,10 +658,10 @@ OJPEGSetupDecode(TIFF* tif) } static int -OJPEGPreDecode(TIFF* tif, tsample_t s) +OJPEGPreDecode(TIFF* tif, uint16 s) { OJPEGState* sp=(OJPEGState*)tif->tif_data; - tstrile_t m; + uint32 m; if (sp->subsamplingcorrect_done==0) OJPEGSubsamplingCorrect(tif); if (sp->readheader_done==0) @@ -637,9 +675,9 @@ OJPEGPreDecode(TIFF* tif, tsample_t s) return(0); } if isTiled(tif) - m=(tstrile_t)tif->tif_curtile; + m=tif->tif_curtile; else - m=(tstrile_t)tif->tif_curstrip; + m=tif->tif_curstrip; if ((sp->writeheader_done!=0) && ((sp->write_cursample!=s) || (sp->write_curstrile>m))) { if (sp->libjpeg_session_active!=0) @@ -648,7 +686,7 @@ OJPEGPreDecode(TIFF* tif, tsample_t s) } if (sp->writeheader_done==0) { - sp->plane_sample_offset=s; + sp->plane_sample_offset=(uint8)s; sp->write_cursample=s; sp->write_curstrile=s*tif->tif_dir.td_stripsperimage; if ((sp->in_buffer_file_pos_log==0) || @@ -739,7 +777,7 @@ OJPEGPreDecodeSkipScanlines(TIFF* tif) } static int -OJPEGDecode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) +OJPEGDecode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s) { OJPEGState* sp=(OJPEGState*)tif->tif_data; (void)s; @@ -757,12 +795,12 @@ OJPEGDecode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) } static int -OJPEGDecodeRaw(TIFF* tif, tidata_t buf, tsize_t cc) +OJPEGDecodeRaw(TIFF* tif, uint8* buf, tmsize_t cc) { static const char module[]="OJPEGDecodeRaw"; OJPEGState* sp=(OJPEGState*)tif->tif_data; uint8* m; - uint32 n; + tmsize_t n; uint8* oy; uint8* ocb; uint8* ocr; @@ -812,12 +850,12 @@ OJPEGDecodeRaw(TIFF* tif, tidata_t buf, tsize_t cc) } static int -OJPEGDecodeScanlines(TIFF* tif, tidata_t buf, tsize_t cc) +OJPEGDecodeScanlines(TIFF* tif, uint8* buf, tmsize_t cc) { static const char module[]="OJPEGDecodeScanlines"; OJPEGState* sp=(OJPEGState*)tif->tif_data; uint8* m; - uint32 n; + tmsize_t n; if (cc%sp->bytes_per_line!=0) { TIFFErrorExt(tif->tif_clientdata,module,"Fractional scanline not read"); @@ -837,13 +875,13 @@ OJPEGDecodeScanlines(TIFF* tif, tidata_t buf, tsize_t cc) } static void -OJPEGPostDecode(TIFF* tif, tidata_t buf, tsize_t cc) +OJPEGPostDecode(TIFF* tif, uint8* buf, tmsize_t cc) { OJPEGState* sp=(OJPEGState*)tif->tif_data; (void)buf; (void)cc; sp->write_curstrile++; - if (sp->write_curstrile%tif->tif_dir.td_stripsperimage==0) + if (sp->write_curstrile%tif->tif_dir.td_stripsperimage==0) { assert(sp->libjpeg_session_active!=0); OJPEGLibjpegSessionAbort(tif); @@ -860,7 +898,7 @@ OJPEGSetupEncode(TIFF* tif) } static int -OJPEGPreEncode(TIFF* tif, tsample_t s) +OJPEGPreEncode(TIFF* tif, uint16 s) { static const char module[]="OJPEGPreEncode"; (void)s; @@ -869,7 +907,7 @@ OJPEGPreEncode(TIFF* tif, tsample_t s) } static int -OJPEGEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) +OJPEGEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s) { static const char module[]="OJPEGEncode"; (void)buf; @@ -895,6 +933,7 @@ OJPEGCleanup(TIFF* tif) { tif->tif_tagmethods.vgetfield=sp->vgetparent; tif->tif_tagmethods.vsetfield=sp->vsetparent; + tif->tif_tagmethods.printdir=sp->printdir; if (sp->qtable[0]!=0) _TIFFfree(sp->qtable[0]); if (sp->qtable[1]!=0) @@ -940,6 +979,8 @@ OJPEGSubsamplingCorrect(TIFF* tif) OJPEGState* sp=(OJPEGState*)tif->tif_data; uint8 mh; uint8 mv; + _TIFFFillStriles( tif ); + assert(sp->subsamplingcorrect_done==0); if ((tif->tif_dir.td_samplesperpixel!=3) || ((tif->tif_dir.td_photometric!=PHOTOMETRIC_YCBCR) && (tif->tif_dir.td_photometric!=PHOTOMETRIC_ITULAB))) @@ -1006,9 +1047,9 @@ OJPEGReadHeaderInfo(TIFF* tif) sp->strile_length=tif->tif_dir.td_rowsperstrip; sp->strile_length_total=sp->image_length; } - sp->samples_per_pixel=tif->tif_dir.td_samplesperpixel; - if (sp->samples_per_pixel==1) + if (tif->tif_dir.td_samplesperpixel==1) { + sp->samples_per_pixel=1; sp->plane_sample_offset=0; sp->samples_per_pixel_per_plane=sp->samples_per_pixel; sp->subsampling_hor=1; @@ -1016,11 +1057,12 @@ OJPEGReadHeaderInfo(TIFF* tif) } else { - if (sp->samples_per_pixel!=3) + if (tif->tif_dir.td_samplesperpixel!=3) { TIFFErrorExt(tif->tif_clientdata,module,"SamplesPerPixel %d not supported for this compression scheme",sp->samples_per_pixel); return(0); } + sp->samples_per_pixel=3; sp->plane_sample_offset=0; if (tif->tif_dir.td_planarconfig==PLANARCONFIG_CONTIG) sp->samples_per_pixel_per_plane=3; @@ -1042,13 +1084,13 @@ OJPEGReadHeaderInfo(TIFF* tif) sp->sos_end[0].in_buffer_source=sp->in_buffer_source; sp->sos_end[0].in_buffer_next_strile=sp->in_buffer_next_strile; sp->sos_end[0].in_buffer_file_pos=sp->in_buffer_file_pos-sp->in_buffer_togo; - sp->sos_end[0].in_buffer_file_togo=sp->in_buffer_file_togo+sp->in_buffer_togo; + sp->sos_end[0].in_buffer_file_togo=sp->in_buffer_file_togo+sp->in_buffer_togo; sp->readheader_done=1; return(1); } static int -OJPEGReadSecondarySos(TIFF* tif, tsample_t s) +OJPEGReadSecondarySos(TIFF* tif, uint16 s) { OJPEGState* sp=(OJPEGState*)tif->tif_data; uint8 m; @@ -1061,7 +1103,7 @@ OJPEGReadSecondarySos(TIFF* tif, tsample_t s) sp->plane_sample_offset--; sp->in_buffer_source=sp->sos_end[sp->plane_sample_offset].in_buffer_source; sp->in_buffer_next_strile=sp->sos_end[sp->plane_sample_offset].in_buffer_next_strile; - sp->in_buffer_file_pos=sp->sos_end[sp->plane_sample_offset].in_buffer_file_pos; + sp->in_buffer_file_pos=sp->sos_end[sp->plane_sample_offset].in_buffer_file_pos; sp->in_buffer_file_pos_log=0; sp->in_buffer_file_togo=sp->sos_end[sp->plane_sample_offset].in_buffer_file_togo; sp->in_buffer_togo=0; @@ -1104,7 +1146,9 @@ OJPEGWriteHeaderInfo(TIFF* tif) OJPEGState* sp=(OJPEGState*)tif->tif_data; uint8** m; uint32 n; - assert(sp->libjpeg_session_active==0); + /* if a previous attempt failed, don't try again */ + if (sp->libjpeg_session_active != 0) + return 0; sp->out_state=ososSoi; sp->restart_index=0; jpeg_std_error(&(sp->libjpeg_jpeg_error_mgr)); @@ -1223,7 +1267,7 @@ OJPEGReadHeaderInfoSec(TIFF* tif) } sp->in_buffer_source=osibsNotSetYet; sp->in_buffer_next_strile=0; - sp->in_buffer_strile_count=tif->tif_dir.td_nstrips; + sp->in_buffer_strile_count=tif->tif_dir.td_nstrips; sp->in_buffer_file_togo=0; sp->in_buffer_togo=0; do @@ -1391,12 +1435,15 @@ OJPEGReadHeaderInfoSecStreamDqt(TIFF* tif) nb[sizeof(uint32)+1]=JPEG_MARKER_DQT; nb[sizeof(uint32)+2]=0; nb[sizeof(uint32)+3]=67; - if (OJPEGReadBlock(sp,65,&nb[sizeof(uint32)+4])==0) + if (OJPEGReadBlock(sp,65,&nb[sizeof(uint32)+4])==0) { + _TIFFfree(nb); return(0); + } o=nb[sizeof(uint32)+4]&15; if (3<o) { TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DQT marker in JPEG data"); + _TIFFfree(nb); return(0); } if (sp->qtable[o]!=0) @@ -1537,11 +1584,10 @@ OJPEGReadHeaderInfoSecStreamSof(TIFF* tif, uint8 marker_id) OJPEGReadSkip(sp,4); else { - /* TODO: probably best to also add check on allowed upper bound, especially x, may cause buffer overflow otherwise i think */ /* Y: Number of lines */ if (OJPEGReadWord(sp,&p)==0) return(0); - if ((p<sp->image_length) && (p<sp->strile_length_total)) + if (((uint32)p<sp->image_length) && ((uint32)p<sp->strile_length_total)) { TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected height"); return(0); @@ -1550,11 +1596,16 @@ OJPEGReadHeaderInfoSecStreamSof(TIFF* tif, uint8 marker_id) /* X: Number of samples per line */ if (OJPEGReadWord(sp,&p)==0) return(0); - if ((p<sp->image_width) && (p<sp->strile_width)) + if (((uint32)p<sp->image_width) && ((uint32)p<sp->strile_width)) { TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected width"); return(0); } + if ((uint32)p>sp->strile_width) + { + TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data image width exceeds expected image width"); + return(0); + } sp->sof_x=p; } /* Nf: Number of image components in frame */ @@ -1717,7 +1768,7 @@ OJPEGReadHeaderInfoSecTablesQTable(TIFF* tif) ob[sizeof(uint32)+2]=0; ob[sizeof(uint32)+3]=67; ob[sizeof(uint32)+4]=m; - TIFFSeekFile(tif,sp->qtable_offset[m],SEEK_SET); + TIFFSeekFile(tif,sp->qtable_offset[m],SEEK_SET); p=TIFFReadFile(tif,&ob[sizeof(uint32)+5],64); if (p!=64) return(0); @@ -1824,7 +1875,7 @@ OJPEGReadHeaderInfoSecTablesAcTable(TIFF* tif) return(0); } } - TIFFSeekFile(tif,sp->actable_offset[m],SEEK_SET); + TIFFSeekFile(tif,sp->actable_offset[m],SEEK_SET); p=TIFFReadFile(tif,o,16); if (p!=16) return(0); @@ -1862,7 +1913,7 @@ static int OJPEGReadBufferFill(OJPEGState* sp) { uint16 m; - tsize_t n; + tmsize_t n; /* TODO: double-check: when subsamplingcorrect is set, no call to TIFFErrorExt or TIFFWarningExt should be made * in any other case, seek or read errors should be passed through */ do @@ -1875,15 +1926,15 @@ OJPEGReadBufferFill(OJPEGState* sp) sp->in_buffer_file_pos_log=1; } m=OJPEG_BUFFER; - if (m>sp->in_buffer_file_togo) + if ((uint64)m>sp->in_buffer_file_togo) m=(uint16)sp->in_buffer_file_togo; - n=TIFFReadFile(sp->tif,sp->in_buffer,(tsize_t)m); + n=TIFFReadFile(sp->tif,sp->in_buffer,(tmsize_t)m); if (n==0) return(0); assert(n>0); assert(n<=OJPEG_BUFFER); assert(n<65536); - assert((uint16)n<=sp->in_buffer_file_togo); + assert((uint64)n<=sp->in_buffer_file_togo); m=(uint16)n; sp->in_buffer_togo=m; sp->in_buffer_cur=sp->in_buffer; @@ -1905,18 +1956,29 @@ OJPEGReadBufferFill(OJPEGState* sp) case osibsJpegInterchangeFormat: sp->in_buffer_source=osibsStrile; case osibsStrile: - if (sp->in_buffer_next_strile==sp->in_buffer_strile_count) + if (!_TIFFFillStriles( sp->tif ) + || sp->tif->tif_dir.td_stripoffset == NULL + || sp->tif->tif_dir.td_stripbytecount == NULL) + return 0; + + if (sp->in_buffer_next_strile==sp->in_buffer_strile_count) sp->in_buffer_source=osibsEof; else { - sp->in_buffer_file_pos=sp->tif->tif_dir.td_stripoffset[sp->in_buffer_next_strile]; + sp->in_buffer_file_pos=sp->tif->tif_dir.td_stripoffset[sp->in_buffer_next_strile]; if (sp->in_buffer_file_pos!=0) { if (sp->in_buffer_file_pos>=sp->file_size) sp->in_buffer_file_pos=0; + else if (sp->tif->tif_dir.td_stripbytecount==NULL) + sp->in_buffer_file_togo=sp->file_size-sp->in_buffer_file_pos; else { - sp->in_buffer_file_togo=sp->tif->tif_dir.td_stripbytecount[sp->in_buffer_next_strile]; + if (sp->tif->tif_dir.td_stripbytecount == 0) { + TIFFErrorExt(sp->tif->tif_clientdata,sp->tif->tif_name,"Strip byte counts are missing"); + return(0); + } + sp->in_buffer_file_togo=sp->tif->tif_dir.td_stripbytecount[sp->in_buffer_next_strile]; if (sp->in_buffer_file_togo==0) sp->in_buffer_file_pos=0; else if (sp->in_buffer_file_pos+sp->in_buffer_file_togo>sp->file_size) @@ -2027,8 +2089,8 @@ OJPEGReadSkip(OJPEGState* sp, uint16 len) { assert(sp->in_buffer_togo==0); n=m; - if (n>sp->in_buffer_file_togo) - n=sp->in_buffer_file_togo; + if ((uint64)n>sp->in_buffer_file_togo) + n=(uint16)sp->in_buffer_file_togo; sp->in_buffer_file_pos+=n; sp->in_buffer_file_togo-=n; sp->in_buffer_file_pos_log=0; @@ -2267,7 +2329,7 @@ OJPEGWriteStreamCompressed(TIFF* tif, void** mem, uint32* len) switch(sp->in_buffer_source) { case osibsStrile: - if (sp->in_buffer_next_strile<sp->in_buffer_strile_count) + if (sp->in_buffer_next_strile<sp->in_buffer_strile_count) sp->out_state=ososRst; else sp->out_state=ososEoi; @@ -2362,7 +2424,7 @@ OJPEGLibjpegJpegErrorMgrOutputMessage(jpeg_common_struct* cinfo) { char buffer[JMSG_LENGTH_MAX]; (*cinfo->err->format_message)(cinfo,buffer); - TIFFWarningExt(((TIFF*)(cinfo->client_data))->tif_clientdata,"LibJpeg", "%s", buffer); + TIFFWarningExt(((TIFF*)(cinfo->client_data))->tif_clientdata,"LibJpeg","%s",buffer); } static void @@ -2370,7 +2432,7 @@ OJPEGLibjpegJpegErrorMgrErrorExit(jpeg_common_struct* cinfo) { char buffer[JMSG_LENGTH_MAX]; (*cinfo->err->format_message)(cinfo,buffer); - TIFFErrorExt(((TIFF*)(cinfo->client_data))->tif_clientdata,"LibJpeg", "%s", buffer); + TIFFErrorExt(((TIFF*)(cinfo->client_data))->tif_clientdata,"LibJpeg","%s",buffer); jpeg_encap_unwind((TIFF*)(cinfo->client_data)); } @@ -2386,7 +2448,7 @@ OJPEGLibjpegJpegSourceMgrFillInputBuffer(jpeg_decompress_struct* cinfo) TIFF* tif=(TIFF*)cinfo->client_data; OJPEGState* sp=(OJPEGState*)tif->tif_data; void* mem=0; - uint32 len=0; + uint32 len=0U; if (OJPEGWriteStream(tif,&mem,&len)==0) { TIFFErrorExt(tif->tif_clientdata,"LibJpeg","Premature end of JPEG data"); @@ -2425,3 +2487,10 @@ OJPEGLibjpegJpegSourceMgrTermSource(jpeg_decompress_struct* cinfo) #endif +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_open.c b/src/3rdparty/libtiff/libtiff/tif_open.c index a567056..8c88328 100644 --- a/src/3rdparty/libtiff/libtiff/tif_open.c +++ b/src/3rdparty/libtiff/libtiff/tif_open.c @@ -1,4 +1,4 @@ -/* $Id: tif_open.c,v 1.33 2006/06/08 14:27:17 dron Exp $ */ +/* $Id: tif_open.c,v 1.46 2010-12-06 16:54:54 faxguy Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler @@ -29,90 +29,22 @@ */ #include "tiffiop.h" -static const long typemask[13] = { - (long)0L, /* TIFF_NOTYPE */ - (long)0x000000ffL, /* TIFF_BYTE */ - (long)0xffffffffL, /* TIFF_ASCII */ - (long)0x0000ffffL, /* TIFF_SHORT */ - (long)0xffffffffL, /* TIFF_LONG */ - (long)0xffffffffL, /* TIFF_RATIONAL */ - (long)0x000000ffL, /* TIFF_SBYTE */ - (long)0x000000ffL, /* TIFF_UNDEFINED */ - (long)0x0000ffffL, /* TIFF_SSHORT */ - (long)0xffffffffL, /* TIFF_SLONG */ - (long)0xffffffffL, /* TIFF_SRATIONAL */ - (long)0xffffffffL, /* TIFF_FLOAT */ - (long)0xffffffffL, /* TIFF_DOUBLE */ -}; -static const int bigTypeshift[13] = { - 0, /* TIFF_NOTYPE */ - 24, /* TIFF_BYTE */ - 0, /* TIFF_ASCII */ - 16, /* TIFF_SHORT */ - 0, /* TIFF_LONG */ - 0, /* TIFF_RATIONAL */ - 24, /* TIFF_SBYTE */ - 24, /* TIFF_UNDEFINED */ - 16, /* TIFF_SSHORT */ - 0, /* TIFF_SLONG */ - 0, /* TIFF_SRATIONAL */ - 0, /* TIFF_FLOAT */ - 0, /* TIFF_DOUBLE */ -}; -static const int litTypeshift[13] = { - 0, /* TIFF_NOTYPE */ - 0, /* TIFF_BYTE */ - 0, /* TIFF_ASCII */ - 0, /* TIFF_SHORT */ - 0, /* TIFF_LONG */ - 0, /* TIFF_RATIONAL */ - 0, /* TIFF_SBYTE */ - 0, /* TIFF_UNDEFINED */ - 0, /* TIFF_SSHORT */ - 0, /* TIFF_SLONG */ - 0, /* TIFF_SRATIONAL */ - 0, /* TIFF_FLOAT */ - 0, /* TIFF_DOUBLE */ -}; - /* * Dummy functions to fill the omitted client procedures. */ static int -_tiffDummyMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) +_tiffDummyMapProc(thandle_t fd, void** pbase, toff_t* psize) { (void) fd; (void) pbase; (void) psize; return (0); } static void -_tiffDummyUnmapProc(thandle_t fd, tdata_t base, toff_t size) +_tiffDummyUnmapProc(thandle_t fd, void* base, toff_t size) { (void) fd; (void) base; (void) size; } -/* - * Initialize the shift & mask tables, and the - * byte swapping state according to the file - * contents and the machine architecture. - */ -static void -TIFFInitOrder(TIFF* tif, int magic) -{ - tif->tif_typemask = typemask; - if (magic == TIFF_BIGENDIAN) { - tif->tif_typeshift = bigTypeshift; -#ifndef WORDS_BIGENDIAN - tif->tif_flags |= TIFF_SWAB; -#endif - } else { - tif->tif_typeshift = litTypeshift; -#ifdef WORDS_BIGENDIAN - tif->tif_flags |= TIFF_SWAB; -#endif - } -} - int _TIFFgetMode(const char* mode, const char* module) { @@ -155,10 +87,36 @@ TIFFClientOpen( int m; const char* cp; + /* The following are configuration checks. They should be redundant, but should not + * compile to any actual code in an optimised release build anyway. If any of them + * fail, (makefile-based or other) configuration is not correct */ + assert(sizeof(uint8)==1); + assert(sizeof(int8)==1); + assert(sizeof(uint16)==2); + assert(sizeof(int16)==2); + assert(sizeof(uint32)==4); + assert(sizeof(int32)==4); + assert(sizeof(uint64)==8); + assert(sizeof(int64)==8); + assert(sizeof(tmsize_t)==sizeof(void*)); + { + union{ + uint8 a8[2]; + uint16 a16; + } n; + n.a8[0]=1; + n.a8[1]=0; + #ifdef WORDS_BIGENDIAN + assert(n.a16==256); + #else + assert(n.a16==1); + #endif + } + m = _TIFFgetMode(mode, module); if (m == -1) goto bad2; - tif = (TIFF *)_TIFFmalloc(sizeof (TIFF) + strlen(name) + 1); + tif = (TIFF *)_TIFFmalloc((tmsize_t)(sizeof (TIFF) + strlen(name) + 1)); if (tif == NULL) { TIFFErrorExt(clientdata, module, "%s: Out of memory (TIFF structure)", name); goto bad2; @@ -167,14 +125,14 @@ TIFFClientOpen( tif->tif_name = (char *)tif + sizeof (TIFF); strcpy(tif->tif_name, name); tif->tif_mode = m &~ (O_CREAT|O_TRUNC); - tif->tif_curdir = (tdir_t) -1; /* non-existent directory */ + tif->tif_curdir = (uint16) -1; /* non-existent directory */ tif->tif_curoff = 0; - tif->tif_curstrip = (tstrip_t) -1; /* invalid strip */ + tif->tif_curstrip = (uint32) -1; /* invalid strip */ tif->tif_row = (uint32) -1; /* read/write pre-increment */ tif->tif_clientdata = clientdata; if (!readproc || !writeproc || !seekproc || !closeproc || !sizeproc) { TIFFErrorExt(clientdata, module, - "One of the client procedures is NULL pointer."); + "One of the client procedures is NULL pointer."); goto bad2; } tif->tif_readproc = readproc; @@ -182,7 +140,7 @@ TIFFClientOpen( tif->tif_seekproc = seekproc; tif->tif_closeproc = closeproc; tif->tif_sizeproc = sizeproc; - if (mapproc) + if (mapproc) tif->tif_mapproc = mapproc; else tif->tif_mapproc = _tiffDummyMapProc; @@ -190,7 +148,7 @@ TIFFClientOpen( tif->tif_unmapproc = unmapproc; else tif->tif_unmapproc = _tiffDummyUnmapProc; - _TIFFSetDefaultCompressionState(tif); /* setup default state */ + _TIFFSetDefaultCompressionState(tif); /* setup default state */ /* * Default is to return data MSB2LSB and enable the * use of memory-mapped files and strip chopping when @@ -200,10 +158,10 @@ TIFFClientOpen( if (m == O_RDONLY ) tif->tif_flags |= TIFF_MAPPED; -#ifdef STRIPCHOP_DEFAULT + #ifdef STRIPCHOP_DEFAULT if (m == O_RDONLY || m == O_RDWR) tif->tif_flags |= STRIPCHOP_DEFAULT; -#endif + #endif /* * Process library-specific flags in the open mode string. @@ -213,16 +171,18 @@ TIFFClientOpen( * TIFF but only supports some braindead idea of what the * vendor thinks TIFF is): * - * 'l' use little-endian byte order for creating a file - * 'b' use big-endian byte order for creating a file - * 'L' read/write information using LSB2MSB bit order - * 'B' read/write information using MSB2LSB bit order - * 'H' read/write information using host bit order - * 'M' enable use of memory-mapped files when supported - * 'm' disable use of memory-mapped files - * 'C' enable strip chopping support when reading - * 'c' disable strip chopping support - * 'h' read TIFF header only, do not load the first IFD + * 'l' use little-endian byte order for creating a file + * 'b' use big-endian byte order for creating a file + * 'L' read/write information using LSB2MSB bit order + * 'B' read/write information using MSB2LSB bit order + * 'H' read/write information using host bit order + * 'M' enable use of memory-mapped files when supported + * 'm' disable use of memory-mapped files + * 'C' enable strip chopping support when reading + * 'c' disable strip chopping support + * 'h' read TIFF header only, do not load the first IFD + * '4' ClassicTIFF for creating a file (default) + * '8' BigTIFF for creating a file * * The use of the 'l' and 'b' flags is strongly discouraged. * These flags are provided solely because numerous vendors, @@ -257,94 +217,120 @@ TIFFClientOpen( */ for (cp = mode; *cp; cp++) switch (*cp) { - case 'b': -#ifndef WORDS_BIGENDIAN - if (m&O_CREAT) - tif->tif_flags |= TIFF_SWAB; -#endif - break; - case 'l': -#ifdef WORDS_BIGENDIAN - if ((m&O_CREAT)) - tif->tif_flags |= TIFF_SWAB; -#endif - break; - case 'B': - tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) | - FILLORDER_MSB2LSB; - break; - case 'L': - tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) | - FILLORDER_LSB2MSB; - break; - case 'H': - tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) | - HOST_FILLORDER; - break; - case 'M': - if (m == O_RDONLY) - tif->tif_flags |= TIFF_MAPPED; - break; - case 'm': - if (m == O_RDONLY) - tif->tif_flags &= ~TIFF_MAPPED; - break; - case 'C': - if (m == O_RDONLY) - tif->tif_flags |= TIFF_STRIPCHOP; - break; - case 'c': - if (m == O_RDONLY) - tif->tif_flags &= ~TIFF_STRIPCHOP; - break; - case 'h': - tif->tif_flags |= TIFF_HEADERONLY; - break; + case 'b': + #ifndef WORDS_BIGENDIAN + if (m&O_CREAT) + tif->tif_flags |= TIFF_SWAB; + #endif + break; + case 'l': + #ifdef WORDS_BIGENDIAN + if ((m&O_CREAT)) + tif->tif_flags |= TIFF_SWAB; + #endif + break; + case 'B': + tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) | + FILLORDER_MSB2LSB; + break; + case 'L': + tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) | + FILLORDER_LSB2MSB; + break; + case 'H': + tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) | + HOST_FILLORDER; + break; + case 'M': + if (m == O_RDONLY) + tif->tif_flags |= TIFF_MAPPED; + break; + case 'm': + if (m == O_RDONLY) + tif->tif_flags &= ~TIFF_MAPPED; + break; + case 'C': + if (m == O_RDONLY) + tif->tif_flags |= TIFF_STRIPCHOP; + break; + case 'c': + if (m == O_RDONLY) + tif->tif_flags &= ~TIFF_STRIPCHOP; + break; + case 'h': + tif->tif_flags |= TIFF_HEADERONLY; + break; + case '8': + if (m&O_CREAT) + tif->tif_flags |= TIFF_BIGTIFF; + break; } /* * Read in TIFF header. */ - if (tif->tif_mode & O_TRUNC || - !ReadOK(tif, &tif->tif_header, sizeof (TIFFHeader))) { + if ((m & O_TRUNC) || + !ReadOK(tif, &tif->tif_header, sizeof (TIFFHeaderClassic))) { if (tif->tif_mode == O_RDONLY) { TIFFErrorExt(tif->tif_clientdata, name, - "Cannot read TIFF header"); + "Cannot read TIFF header"); goto bad; } /* * Setup header and write. */ -#ifdef WORDS_BIGENDIAN - tif->tif_header.tiff_magic = tif->tif_flags & TIFF_SWAB + #ifdef WORDS_BIGENDIAN + tif->tif_header.common.tiff_magic = tif->tif_flags & TIFF_SWAB ? TIFF_LITTLEENDIAN : TIFF_BIGENDIAN; -#else - tif->tif_header.tiff_magic = tif->tif_flags & TIFF_SWAB + #else + tif->tif_header.common.tiff_magic = tif->tif_flags & TIFF_SWAB ? TIFF_BIGENDIAN : TIFF_LITTLEENDIAN; -#endif - tif->tif_header.tiff_version = TIFF_VERSION; - if (tif->tif_flags & TIFF_SWAB) - TIFFSwabShort(&tif->tif_header.tiff_version); - tif->tif_header.tiff_diroff = 0; /* filled in later */ - - - /* - * The doc for "fopen" for some STD_C_LIBs says that if you - * open a file for modify ("+"), then you must fseek (or - * fflush?) between any freads and fwrites. This is not - * necessary on most systems, but has been shown to be needed - * on Solaris. - */ - TIFFSeekFile( tif, 0, SEEK_SET ); - - if (!WriteOK(tif, &tif->tif_header, sizeof (TIFFHeader))) { + #endif + if (!(tif->tif_flags&TIFF_BIGTIFF)) + { + tif->tif_header.common.tiff_version = TIFF_VERSION_CLASSIC; + tif->tif_header.classic.tiff_diroff = 0; + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabShort(&tif->tif_header.common.tiff_version); + tif->tif_header_size = sizeof(TIFFHeaderClassic); + } + else + { + tif->tif_header.common.tiff_version = TIFF_VERSION_BIG; + tif->tif_header.big.tiff_offsetsize = 8; + tif->tif_header.big.tiff_unused = 0; + tif->tif_header.big.tiff_diroff = 0; + if (tif->tif_flags & TIFF_SWAB) + { + TIFFSwabShort(&tif->tif_header.common.tiff_version); + TIFFSwabShort(&tif->tif_header.big.tiff_offsetsize); + } + tif->tif_header_size = sizeof (TIFFHeaderBig); + } + /* + * The doc for "fopen" for some STD_C_LIBs says that if you + * open a file for modify ("+"), then you must fseek (or + * fflush?) between any freads and fwrites. This is not + * necessary on most systems, but has been shown to be needed + * on Solaris. + */ + TIFFSeekFile( tif, 0, SEEK_SET ); + if (!WriteOK(tif, &tif->tif_header, (tmsize_t)(tif->tif_header_size))) { TIFFErrorExt(tif->tif_clientdata, name, - "Error writing TIFF header"); + "Error writing TIFF header"); goto bad; } /* * Setup the byte order handling. */ - TIFFInitOrder(tif, tif->tif_header.tiff_magic); + if (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN) { + #ifndef WORDS_BIGENDIAN + tif->tif_flags |= TIFF_SWAB; + #endif + } else { + #ifdef WORDS_BIGENDIAN + tif->tif_flags |= TIFF_SWAB; + #endif + } /* * Setup default directory. */ @@ -359,95 +345,139 @@ TIFFClientOpen( /* * Setup the byte order handling. */ - if (tif->tif_header.tiff_magic != TIFF_BIGENDIAN && - tif->tif_header.tiff_magic != TIFF_LITTLEENDIAN -#if MDI_SUPPORT + if (tif->tif_header.common.tiff_magic != TIFF_BIGENDIAN && + tif->tif_header.common.tiff_magic != TIFF_LITTLEENDIAN + #if MDI_SUPPORT && -#if HOST_BIGENDIAN - tif->tif_header.tiff_magic != MDI_BIGENDIAN -#else - tif->tif_header.tiff_magic != MDI_LITTLEENDIAN -#endif + #if HOST_BIGENDIAN + tif->tif_header.common.tiff_magic != MDI_BIGENDIAN + #else + tif->tif_header.common.tiff_magic != MDI_LITTLEENDIAN + #endif ) { TIFFErrorExt(tif->tif_clientdata, name, - "Not a TIFF or MDI file, bad magic number %d (0x%x)", -#else + "Not a TIFF or MDI file, bad magic number %d (0x%x)", + #else ) { TIFFErrorExt(tif->tif_clientdata, name, - "Not a TIFF file, bad magic number %d (0x%x)", -#endif - tif->tif_header.tiff_magic, - tif->tif_header.tiff_magic); + "Not a TIFF file, bad magic number %d (0x%x)", + #endif + tif->tif_header.common.tiff_magic, + tif->tif_header.common.tiff_magic); goto bad; } - TIFFInitOrder(tif, tif->tif_header.tiff_magic); - /* - * Swap header if required. - */ - if (tif->tif_flags & TIFF_SWAB) { - TIFFSwabShort(&tif->tif_header.tiff_version); - TIFFSwabLong(&tif->tif_header.tiff_diroff); - } - /* - * Now check version (if needed, it's been byte-swapped). - * Note that this isn't actually a version number, it's a - * magic number that doesn't change (stupid). - */ - if (tif->tif_header.tiff_version == TIFF_BIGTIFF_VERSION) { - TIFFErrorExt(tif->tif_clientdata, name, - "This is a BigTIFF file. This format not supported\n" - "by this version of libtiff." ); - goto bad; + if (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN) { + #ifndef WORDS_BIGENDIAN + tif->tif_flags |= TIFF_SWAB; + #endif + } else { + #ifdef WORDS_BIGENDIAN + tif->tif_flags |= TIFF_SWAB; + #endif } - if (tif->tif_header.tiff_version != TIFF_VERSION) { + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabShort(&tif->tif_header.common.tiff_version); + if ((tif->tif_header.common.tiff_version != TIFF_VERSION_CLASSIC)&& + (tif->tif_header.common.tiff_version != TIFF_VERSION_BIG)) { TIFFErrorExt(tif->tif_clientdata, name, "Not a TIFF file, bad version number %d (0x%x)", - tif->tif_header.tiff_version, - tif->tif_header.tiff_version); + tif->tif_header.common.tiff_version, + tif->tif_header.common.tiff_version); goto bad; } + if (tif->tif_header.common.tiff_version == TIFF_VERSION_CLASSIC) + { + if (tif->tif_flags & TIFF_SWAB) + TIFFSwabLong(&tif->tif_header.classic.tiff_diroff); + tif->tif_header_size = sizeof(TIFFHeaderClassic); + } + else + { + if (!ReadOK(tif, ((uint8*)(&tif->tif_header) + sizeof(TIFFHeaderClassic)), (sizeof(TIFFHeaderBig)-sizeof(TIFFHeaderClassic)))) + { + TIFFErrorExt(tif->tif_clientdata, name, + "Cannot read TIFF header"); + goto bad; + } + if (tif->tif_flags & TIFF_SWAB) + { + TIFFSwabShort(&tif->tif_header.big.tiff_offsetsize); + TIFFSwabLong8(&tif->tif_header.big.tiff_diroff); + } + if (tif->tif_header.big.tiff_offsetsize != 8) + { + TIFFErrorExt(tif->tif_clientdata, name, + "Not a TIFF file, bad BigTIFF offsetsize %d (0x%x)", + tif->tif_header.big.tiff_offsetsize, + tif->tif_header.big.tiff_offsetsize); + goto bad; + } + if (tif->tif_header.big.tiff_unused != 0) + { + TIFFErrorExt(tif->tif_clientdata, name, + "Not a TIFF file, bad BigTIFF unused %d (0x%x)", + tif->tif_header.big.tiff_unused, + tif->tif_header.big.tiff_unused); + goto bad; + } + tif->tif_header_size = sizeof(TIFFHeaderBig); + tif->tif_flags |= TIFF_BIGTIFF; + } tif->tif_flags |= TIFF_MYBUFFER; tif->tif_rawcp = tif->tif_rawdata = 0; tif->tif_rawdatasize = 0; + tif->tif_rawdataoff = 0; + tif->tif_rawdataloaded = 0; - /* - * Sometimes we do not want to read the first directory (for example, - * it may be broken) and want to proceed to other directories. I this - * case we use the TIFF_HEADERONLY flag to open file and return - * immediately after reading TIFF header. - */ - if (tif->tif_flags & TIFF_HEADERONLY) - return (tif); - - /* - * Setup initial directory. - */ switch (mode[0]) { - case 'r': - tif->tif_nextdiroff = tif->tif_header.tiff_diroff; - /* - * Try to use a memory-mapped file if the client - * has not explicitly suppressed usage with the - * 'm' flag in the open mode (see above). - */ - if ((tif->tif_flags & TIFF_MAPPED) && - !TIFFMapFileContents(tif, (tdata_t*) &tif->tif_base, &tif->tif_size)) - tif->tif_flags &= ~TIFF_MAPPED; - if (TIFFReadDirectory(tif)) { - tif->tif_rawcc = -1; - tif->tif_flags |= TIFF_BUFFERSETUP; + case 'r': + if (!(tif->tif_flags&TIFF_BIGTIFF)) + tif->tif_nextdiroff = tif->tif_header.classic.tiff_diroff; + else + tif->tif_nextdiroff = tif->tif_header.big.tiff_diroff; + /* + * Try to use a memory-mapped file if the client + * has not explicitly suppressed usage with the + * 'm' flag in the open mode (see above). + */ + if (tif->tif_flags & TIFF_MAPPED) + { + toff_t n; + if (TIFFMapFileContents(tif,(void**)(&tif->tif_base),&n)) + { + tif->tif_size=(tmsize_t)n; + assert((toff_t)tif->tif_size==n); + } + else + tif->tif_flags &= ~TIFF_MAPPED; + } + /* + * Sometimes we do not want to read the first directory (for example, + * it may be broken) and want to proceed to other directories. I this + * case we use the TIFF_HEADERONLY flag to open file and return + * immediately after reading TIFF header. + */ + if (tif->tif_flags & TIFF_HEADERONLY) + return (tif); + + /* + * Setup initial directory. + */ + if (TIFFReadDirectory(tif)) { + tif->tif_rawcc = (tmsize_t)-1; + tif->tif_flags |= TIFF_BUFFERSETUP; + return (tif); + } + break; + case 'a': + /* + * New directories are automatically append + * to the end of the directory chain when they + * are written out (see TIFFWriteDirectory). + */ + if (!TIFFDefaultDirectory(tif)) + goto bad; return (tif); - } - break; - case 'a': - /* - * New directories are automatically append - * to the end of the directory chain when they - * are written out (see TIFFWriteDirectory). - */ - if (!TIFFDefaultDirectory(tif)) - goto bad; - return (tif); } bad: tif->tif_mode = O_RDONLY; /* XXX avoid flush */ @@ -562,7 +592,7 @@ TIFFCurrentRow(TIFF* tif) /* * Return index of the current directory. */ -tdir_t +uint16 TIFFCurrentDirectory(TIFF* tif) { return (tif->tif_curdir); @@ -571,7 +601,7 @@ TIFFCurrentDirectory(TIFF* tif) /* * Return current strip. */ -tstrip_t +uint32 TIFFCurrentStrip(TIFF* tif) { return (tif->tif_curstrip); @@ -580,7 +610,7 @@ TIFFCurrentStrip(TIFF* tif) /* * Return current tile. */ -ttile_t +uint32 TIFFCurrentTile(TIFF* tif) { return (tif->tif_curtile); @@ -619,7 +649,7 @@ TIFFIsMSB2LSB(TIFF* tif) int TIFFIsBigEndian(TIFF* tif) { - return (tif->tif_header.tiff_magic == TIFF_BIGENDIAN); + return (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN); } /* @@ -686,3 +716,10 @@ TIFFGetUnmapFileProc(TIFF* tif) } /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_packbits.c b/src/3rdparty/libtiff/libtiff/tif_packbits.c index 171a269..9e77190 100644 --- a/src/3rdparty/libtiff/libtiff/tif_packbits.c +++ b/src/3rdparty/libtiff/libtiff/tif_packbits.c @@ -1,4 +1,4 @@ -/* $Id: tif_packbits.c,v 1.13.2.1 2009-01-01 00:10:43 bfriesen Exp $ */ +/* $Id: tif_packbits.c,v 1.22 2012-06-20 05:25:33 fwarmerdam Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler @@ -34,19 +34,19 @@ #include <stdio.h> static int -PackBitsPreEncode(TIFF* tif, tsample_t s) +PackBitsPreEncode(TIFF* tif, uint16 s) { (void) s; - if (!(tif->tif_data = (tidata_t)_TIFFmalloc(sizeof(tsize_t)))) + if (!(tif->tif_data = (uint8*)_TIFFmalloc(sizeof(tmsize_t)))) return (0); /* * Calculate the scanline/tile-width size in bytes. */ if (isTiled(tif)) - *(tsize_t*)tif->tif_data = TIFFTileRowSize(tif); + *(tmsize_t*)tif->tif_data = TIFFTileRowSize(tif); else - *(tsize_t*)tif->tif_data = TIFFScanlineSize(tif); + *(tmsize_t*)tif->tif_data = TIFFScanlineSize(tif); return (1); } @@ -59,20 +59,15 @@ PackBitsPostEncode(TIFF* tif) } /* - * NB: tidata is the type representing *(tidata_t); - * if tidata_t is made signed then this type must - * be adjusted accordingly. - */ -typedef unsigned char tidata; - -/* * Encode a run of pixels. */ static int -PackBitsEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) +PackBitsEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s) { unsigned char* bp = (unsigned char*) buf; - tidata_t op, ep, lastliteral; + uint8* op; + uint8* ep; + uint8* lastliteral; long n, slop; int b; enum { BASE, LITERAL, RUN, LITERAL_RUN } state; @@ -98,8 +93,8 @@ PackBitsEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) * front of the buffer. */ if (state == LITERAL || state == LITERAL_RUN) { - slop = op - lastliteral; - tif->tif_rawcc += lastliteral - tif->tif_rawcp; + slop = (long)(op - lastliteral); + tif->tif_rawcc += (tmsize_t)(lastliteral - tif->tif_rawcp); if (!TIFFFlushData1(tif)) return (-1); op = tif->tif_rawcp; @@ -107,7 +102,7 @@ PackBitsEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) *op++ = *lastliteral++; lastliteral = tif->tif_rawcp; } else { - tif->tif_rawcc += op - tif->tif_rawcp; + tif->tif_rawcc += (tmsize_t)(op - tif->tif_rawcp); if (!TIFFFlushData1(tif)) return (-1); op = tif->tif_rawcp; @@ -118,17 +113,17 @@ PackBitsEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) if (n > 1) { state = RUN; if (n > 128) { - *op++ = (tidata) -127; - *op++ = (tidataval_t) b; + *op++ = (uint8) -127; + *op++ = (uint8) b; n -= 128; goto again; } - *op++ = (tidataval_t)(-(n-1)); - *op++ = (tidataval_t) b; + *op++ = (uint8)(-(n-1)); + *op++ = (uint8) b; } else { lastliteral = op; *op++ = 0; - *op++ = (tidataval_t) b; + *op++ = (uint8) b; state = LITERAL; } break; @@ -136,33 +131,33 @@ PackBitsEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) if (n > 1) { state = LITERAL_RUN; if (n > 128) { - *op++ = (tidata) -127; - *op++ = (tidataval_t) b; + *op++ = (uint8) -127; + *op++ = (uint8) b; n -= 128; goto again; } - *op++ = (tidataval_t)(-(n-1)); /* encode run */ - *op++ = (tidataval_t) b; + *op++ = (uint8)(-(n-1)); /* encode run */ + *op++ = (uint8) b; } else { /* extend literal */ if (++(*lastliteral) == 127) state = BASE; - *op++ = (tidataval_t) b; + *op++ = (uint8) b; } break; case RUN: /* last object was run */ if (n > 1) { if (n > 128) { - *op++ = (tidata) -127; - *op++ = (tidataval_t) b; + *op++ = (uint8) -127; + *op++ = (uint8) b; n -= 128; goto again; } - *op++ = (tidataval_t)(-(n-1)); - *op++ = (tidataval_t) b; + *op++ = (uint8)(-(n-1)); + *op++ = (uint8) b; } else { lastliteral = op; *op++ = 0; - *op++ = (tidataval_t) b; + *op++ = (uint8) b; state = LITERAL; } break; @@ -173,7 +168,7 @@ PackBitsEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) * case we convert literal-run-literal * to a single literal. */ - if (n == 1 && op[-2] == (tidata) -1 && + if (n == 1 && op[-2] == (uint8) -1 && *lastliteral < 126) { state = (((*lastliteral) += 2) == 127 ? BASE : LITERAL); @@ -183,7 +178,7 @@ PackBitsEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) goto again; } } - tif->tif_rawcc += op - tif->tif_rawcp; + tif->tif_rawcc += (tmsize_t)(op - tif->tif_rawcp); tif->tif_rawcp = op; return (1); } @@ -196,12 +191,12 @@ PackBitsEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) * when it was encoded by strips. */ static int -PackBitsEncodeChunk(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) +PackBitsEncodeChunk(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s) { - tsize_t rowsize = *(tsize_t*)tif->tif_data; + tmsize_t rowsize = *(tmsize_t*)tif->tif_data; - while ((long)cc > 0) { - int chunk = rowsize; + while (cc > 0) { + tmsize_t chunk = rowsize; if( cc < chunk ) chunk = cc; @@ -215,17 +210,18 @@ PackBitsEncodeChunk(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) } static int -PackBitsDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) +PackBitsDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s) { + static const char module[] = "PackBitsDecode"; char *bp; - tsize_t cc; + tmsize_t cc; long n; int b; (void) s; bp = (char*) tif->tif_rawcp; cc = tif->tif_rawcc; - while (cc > 0 && (long)occ > 0) { + while (cc > 0 && occ > 0) { n = (long) *bp++, cc--; /* * Watch out for compilers that @@ -236,39 +232,43 @@ PackBitsDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) if (n < 0) { /* replicate next byte -n+1 times */ if (n == -128) /* nop */ continue; - n = -n + 1; - if( occ < n ) - { - TIFFWarningExt(tif->tif_clientdata, tif->tif_name, - "PackBitsDecode: discarding %ld bytes " - "to avoid buffer overrun", - n - occ); - n = occ; - } + n = -n + 1; + if( occ < (tmsize_t)n ) + { + TIFFWarningExt(tif->tif_clientdata, module, + "Discarding %lu bytes to avoid buffer overrun", + (unsigned long) ((tmsize_t)n - occ)); + n = (long)occ; + } occ -= n; b = *bp++, cc--; while (n-- > 0) - *op++ = (tidataval_t) b; + *op++ = (uint8) b; } else { /* copy next n+1 bytes literally */ - if (occ < n + 1) - { - TIFFWarningExt(tif->tif_clientdata, tif->tif_name, - "PackBitsDecode: discarding %ld bytes " - "to avoid buffer overrun", - n - occ + 1); - n = occ - 1; - } - _TIFFmemcpy(op, bp, ++n); + if (occ < (tmsize_t)(n + 1)) + { + TIFFWarningExt(tif->tif_clientdata, module, + "Discarding %lu bytes to avoid buffer overrun", + (unsigned long) ((tmsize_t)n - occ + 1)); + n = (long)occ - 1; + } + if (cc < (tmsize_t) (n+1)) + { + TIFFWarningExt(tif->tif_clientdata, module, + "Terminating PackBitsDecode due to lack of data."); + break; + } + _TIFFmemcpy(op, bp, ++n); op += n; occ -= n; bp += n; cc -= n; } } - tif->tif_rawcp = (tidata_t) bp; + tif->tif_rawcp = (uint8*) bp; tif->tif_rawcc = cc; if (occ > 0) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "PackBitsDecode: Not enough data for scanline %ld", - (long) tif->tif_row); + TIFFErrorExt(tif->tif_clientdata, module, + "Not enough data for scanline %lu", + (unsigned long) tif->tif_row); return (0); } return (1); @@ -282,7 +282,7 @@ TIFFInitPackBits(TIFF* tif, int scheme) tif->tif_decodestrip = PackBitsDecode; tif->tif_decodetile = PackBitsDecode; tif->tif_preencode = PackBitsPreEncode; - tif->tif_postencode = PackBitsPostEncode; + tif->tif_postencode = PackBitsPostEncode; tif->tif_encoderow = PackBitsEncode; tif->tif_encodestrip = PackBitsEncodeChunk; tif->tif_encodetile = PackBitsEncodeChunk; @@ -291,3 +291,10 @@ TIFFInitPackBits(TIFF* tif, int scheme) #endif /* PACKBITS_SUPPORT */ /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_pixarlog.c b/src/3rdparty/libtiff/libtiff/tif_pixarlog.c index 5ad84f8..e583117 100644 --- a/src/3rdparty/libtiff/libtiff/tif_pixarlog.c +++ b/src/3rdparty/libtiff/libtiff/tif_pixarlog.c @@ -1,4 +1,4 @@ -/* $Id: tif_pixarlog.c,v 1.15.2.3 2009-01-01 00:10:43 bfriesen Exp $ */ +/* $Id: tif_pixarlog.c,v 1.38 2012-06-21 01:01:53 fwarmerdam Exp $ */ /* * Copyright (c) 1996-1997 Sam Leffler @@ -83,7 +83,10 @@ * The codec also handle byte swapping the encoded values as necessary * since the library does not have the information necessary * to know the bit depth of the raw unencoded buffer. - * + * + * NOTE: This decoder does not appear to update tif_rawcp, and tif_rawcc. + * This can cause problems with the implementation of CHUNKY_STRIP_READ_SUPPORT + * as noted in http://trac.osgeo.org/gdal/ticket/3894. FrankW - Jan'11 */ #include "tif_predict.h" @@ -108,7 +111,7 @@ static float LogK1, LogK2; #define REPEAT(n, op) { int i; i=n; do { i--; op; } while (i>0); } static void -horizontalAccumulateF(uint16 *wp, int n, int stride, float *op, +horizontalAccumulateF(uint16 *wp, int n, int stride, float *op, float *ToLinearF) { register unsigned int cr, cg, cb, ca, mask; @@ -117,9 +120,9 @@ horizontalAccumulateF(uint16 *wp, int n, int stride, float *op, if (n >= stride) { mask = CODE_MASK; if (stride == 3) { - t0 = ToLinearF[cr = wp[0]]; - t1 = ToLinearF[cg = wp[1]]; - t2 = ToLinearF[cb = wp[2]]; + t0 = ToLinearF[cr = (wp[0] & mask)]; + t1 = ToLinearF[cg = (wp[1] & mask)]; + t2 = ToLinearF[cb = (wp[2] & mask)]; op[0] = t0; op[1] = t1; op[2] = t2; @@ -136,10 +139,10 @@ horizontalAccumulateF(uint16 *wp, int n, int stride, float *op, op[2] = t2; } } else if (stride == 4) { - t0 = ToLinearF[cr = wp[0]]; - t1 = ToLinearF[cg = wp[1]]; - t2 = ToLinearF[cb = wp[2]]; - t3 = ToLinearF[ca = wp[3]]; + t0 = ToLinearF[cr = (wp[0] & mask)]; + t1 = ToLinearF[cg = (wp[1] & mask)]; + t2 = ToLinearF[cb = (wp[2] & mask)]; + t3 = ToLinearF[ca = (wp[3] & mask)]; op[0] = t0; op[1] = t1; op[2] = t2; @@ -183,9 +186,9 @@ horizontalAccumulate12(uint16 *wp, int n, int stride, int16 *op, if (n >= stride) { mask = CODE_MASK; if (stride == 3) { - t0 = ToLinearF[cr = wp[0]] * SCALE12; - t1 = ToLinearF[cg = wp[1]] * SCALE12; - t2 = ToLinearF[cb = wp[2]] * SCALE12; + t0 = ToLinearF[cr = (wp[0] & mask)] * SCALE12; + t1 = ToLinearF[cg = (wp[1] & mask)] * SCALE12; + t2 = ToLinearF[cb = (wp[2] & mask)] * SCALE12; op[0] = CLAMP12(t0); op[1] = CLAMP12(t1); op[2] = CLAMP12(t2); @@ -202,10 +205,10 @@ horizontalAccumulate12(uint16 *wp, int n, int stride, int16 *op, op[2] = CLAMP12(t2); } } else if (stride == 4) { - t0 = ToLinearF[cr = wp[0]] * SCALE12; - t1 = ToLinearF[cg = wp[1]] * SCALE12; - t2 = ToLinearF[cb = wp[2]] * SCALE12; - t3 = ToLinearF[ca = wp[3]] * SCALE12; + t0 = ToLinearF[cr = (wp[0] & mask)] * SCALE12; + t1 = ToLinearF[cg = (wp[1] & mask)] * SCALE12; + t2 = ToLinearF[cb = (wp[2] & mask)] * SCALE12; + t3 = ToLinearF[ca = (wp[3] & mask)] * SCALE12; op[0] = CLAMP12(t0); op[1] = CLAMP12(t1); op[2] = CLAMP12(t2); @@ -247,9 +250,9 @@ horizontalAccumulate16(uint16 *wp, int n, int stride, uint16 *op, if (n >= stride) { mask = CODE_MASK; if (stride == 3) { - op[0] = ToLinear16[cr = wp[0]]; - op[1] = ToLinear16[cg = wp[1]]; - op[2] = ToLinear16[cb = wp[2]]; + op[0] = ToLinear16[cr = (wp[0] & mask)]; + op[1] = ToLinear16[cg = (wp[1] & mask)]; + op[2] = ToLinear16[cb = (wp[2] & mask)]; n -= 3; while (n > 0) { wp += 3; @@ -260,10 +263,10 @@ horizontalAccumulate16(uint16 *wp, int n, int stride, uint16 *op, op[2] = ToLinear16[(cb += wp[2]) & mask]; } } else if (stride == 4) { - op[0] = ToLinear16[cr = wp[0]]; - op[1] = ToLinear16[cg = wp[1]]; - op[2] = ToLinear16[cb = wp[2]]; - op[3] = ToLinear16[ca = wp[3]]; + op[0] = ToLinear16[cr = (wp[0] & mask)]; + op[1] = ToLinear16[cg = (wp[1] & mask)]; + op[2] = ToLinear16[cb = (wp[2] & mask)]; + op[3] = ToLinear16[ca = (wp[3] & mask)]; n -= 4; while (n > 0) { wp += 4; @@ -342,9 +345,9 @@ horizontalAccumulate8(uint16 *wp, int n, int stride, unsigned char *op, if (n >= stride) { mask = CODE_MASK; if (stride == 3) { - op[0] = ToLinear8[cr = wp[0]]; - op[1] = ToLinear8[cg = wp[1]]; - op[2] = ToLinear8[cb = wp[2]]; + op[0] = ToLinear8[cr = (wp[0] & mask)]; + op[1] = ToLinear8[cg = (wp[1] & mask)]; + op[2] = ToLinear8[cb = (wp[2] & mask)]; n -= 3; while (n > 0) { n -= 3; @@ -355,10 +358,10 @@ horizontalAccumulate8(uint16 *wp, int n, int stride, unsigned char *op, op[2] = ToLinear8[(cb += wp[2]) & mask]; } } else if (stride == 4) { - op[0] = ToLinear8[cr = wp[0]]; - op[1] = ToLinear8[cg = wp[1]]; - op[2] = ToLinear8[cb = wp[2]]; - op[3] = ToLinear8[ca = wp[3]]; + op[0] = ToLinear8[cr = (wp[0] & mask)]; + op[1] = ToLinear8[cg = (wp[1] & mask)]; + op[2] = ToLinear8[cb = (wp[2] & mask)]; + op[3] = ToLinear8[ca = (wp[3] & mask)]; n -= 4; while (n > 0) { n -= 4; @@ -393,9 +396,9 @@ horizontalAccumulate8abgr(uint16 *wp, int n, int stride, unsigned char *op, mask = CODE_MASK; if (stride == 3) { op[0] = 0; - t1 = ToLinear8[cb = wp[2]]; - t2 = ToLinear8[cg = wp[1]]; - t3 = ToLinear8[cr = wp[0]]; + t1 = ToLinear8[cb = (wp[2] & mask)]; + t2 = ToLinear8[cg = (wp[1] & mask)]; + t3 = ToLinear8[cr = (wp[0] & mask)]; op[1] = t1; op[2] = t2; op[3] = t3; @@ -413,10 +416,10 @@ horizontalAccumulate8abgr(uint16 *wp, int n, int stride, unsigned char *op, op[3] = t3; } } else if (stride == 4) { - t0 = ToLinear8[ca = wp[3]]; - t1 = ToLinear8[cb = wp[2]]; - t2 = ToLinear8[cg = wp[1]]; - t3 = ToLinear8[cr = wp[0]]; + t0 = ToLinear8[ca = (wp[3] & mask)]; + t1 = ToLinear8[cb = (wp[2] & mask)]; + t2 = ToLinear8[cg = (wp[1] & mask)]; + t3 = ToLinear8[cr = (wp[0] & mask)]; op[0] = t0; op[1] = t1; op[2] = t2; @@ -587,11 +590,11 @@ PixarLogMakeTables(PixarLogState *sp) return 1; } -#define DecoderState(tif) ((PixarLogState*) (tif)->tif_data) -#define EncoderState(tif) ((PixarLogState*) (tif)->tif_data) +#define DecoderState(tif) ((PixarLogState*) (tif)->tif_data) +#define EncoderState(tif) ((PixarLogState*) (tif)->tif_data) -static int PixarLogEncode(TIFF*, tidata_t, tsize_t, tsample_t); -static int PixarLogDecode(TIFF*, tidata_t, tsize_t, tsample_t); +static int PixarLogEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s); +static int PixarLogDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s); #define PIXARLOGDATAFMT_UNKNOWN -1 @@ -630,10 +633,10 @@ PixarLogGuessDataFmt(TIFFDirectory *td) return guess; } -static uint32 -multiply(size_t m1, size_t m2) +static tmsize_t +multiply_ms(tmsize_t m1, tmsize_t m2) { - uint32 bytes = m1 * m2; + tmsize_t bytes = m1 * m2; if (m1 && bytes / m1 != m2) bytes = 0; @@ -642,28 +645,35 @@ multiply(size_t m1, size_t m2) } static int +PixarLogFixupTags(TIFF* tif) +{ + (void) tif; + return (1); +} + +static int PixarLogSetupDecode(TIFF* tif) { + static const char module[] = "PixarLogSetupDecode"; TIFFDirectory *td = &tif->tif_dir; PixarLogState* sp = DecoderState(tif); - tsize_t tbuf_size; - static const char module[] = "PixarLogSetupDecode"; + tmsize_t tbuf_size; assert(sp != NULL); /* Make sure no byte swapping happens on the data * after decompression. */ - tif->tif_postdecode = _TIFFNoPostDecode; + tif->tif_postdecode = _TIFFNoPostDecode; /* for some reason, we can't do this in TIFFInitPixarLog */ sp->stride = (td->td_planarconfig == PLANARCONFIG_CONTIG ? td->td_samplesperpixel : 1); - tbuf_size = multiply(multiply(multiply(sp->stride, td->td_imagewidth), + tbuf_size = multiply_ms(multiply_ms(multiply_ms(sp->stride, td->td_imagewidth), td->td_rowsperstrip), sizeof(uint16)); if (tbuf_size == 0) - return (0); - sp->tbuf = (uint16 *) _TIFFmalloc(tbuf_size); + return (0); /* TODO: this is an error return without error report through TIFFErrorExt */ + sp->tbuf = (uint16 *) _TIFFmalloc(tbuf_size+sizeof(uint16)*sp->stride); if (sp->tbuf == NULL) return (0); if (sp->user_datafmt == PIXARLOGDATAFMT_UNKNOWN) @@ -676,7 +686,7 @@ PixarLogSetupDecode(TIFF* tif) } if (inflateInit(&sp->stream) != Z_OK) { - TIFFErrorExt(tif->tif_clientdata, module, "%s: %s", tif->tif_name, sp->stream.msg); + TIFFErrorExt(tif->tif_clientdata, module, "%s", sp->stream.msg); return (0); } else { sp->state |= PLSTATE_INIT; @@ -688,24 +698,36 @@ PixarLogSetupDecode(TIFF* tif) * Setup state for decoding a strip. */ static int -PixarLogPreDecode(TIFF* tif, tsample_t s) +PixarLogPreDecode(TIFF* tif, uint16 s) { + static const char module[] = "PixarLogPreDecode"; PixarLogState* sp = DecoderState(tif); (void) s; assert(sp != NULL); sp->stream.next_in = tif->tif_rawdata; - sp->stream.avail_in = tif->tif_rawcc; + assert(sizeof(sp->stream.avail_in)==4); /* if this assert gets raised, + we need to simplify this code to reflect a ZLib that is likely updated + to deal with 8byte memory sizes, though this code will respond + apropriately even before we simplify it */ + sp->stream.avail_in = (uInt) tif->tif_rawcc; + if ((tmsize_t)sp->stream.avail_in != tif->tif_rawcc) + { + TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size"); + return (0); + } return (inflateReset(&sp->stream) == Z_OK); } static int -PixarLogDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) +PixarLogDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s) { + static const char module[] = "PixarLogDecode"; TIFFDirectory *td = &tif->tif_dir; PixarLogState* sp = DecoderState(tif); - static const char module[] = "PixarLogDecode"; - int i, nsamples, llen; + tmsize_t i; + tmsize_t nsamples; + int llen; uint16 *up; switch (sp->user_datafmt) { @@ -722,7 +744,7 @@ PixarLogDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) nsamples = occ; break; default: - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, + TIFFErrorExt(tif->tif_clientdata, module, "%d bit input not supported in PixarLog", td->td_bitspersample); return 0; @@ -733,7 +755,16 @@ PixarLogDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) (void) s; assert(sp != NULL); sp->stream.next_out = (unsigned char *) sp->tbuf; - sp->stream.avail_out = nsamples * sizeof(uint16); + assert(sizeof(sp->stream.avail_out)==4); /* if this assert gets raised, + we need to simplify this code to reflect a ZLib that is likely updated + to deal with 8byte memory sizes, though this code will respond + apropriately even before we simplify it */ + sp->stream.avail_out = (uInt) (nsamples * sizeof(uint16)); + if (sp->stream.avail_out != nsamples * sizeof(uint16)) + { + TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size"); + return (0); + } do { int state = inflate(&sp->stream, Z_PARTIAL_FLUSH); if (state == Z_STREAM_END) { @@ -741,15 +772,15 @@ PixarLogDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) } if (state == Z_DATA_ERROR) { TIFFErrorExt(tif->tif_clientdata, module, - "%s: Decoding error at scanline %d, %s", - tif->tif_name, tif->tif_row, sp->stream.msg); + "Decoding error at scanline %lu, %s", + (unsigned long) tif->tif_row, sp->stream.msg); if (inflateSync(&sp->stream) != Z_OK) return (0); continue; } if (state != Z_OK) { - TIFFErrorExt(tif->tif_clientdata, module, "%s: zlib error: %s", - tif->tif_name, sp->stream.msg); + TIFFErrorExt(tif->tif_clientdata, module, "ZLib error: %s", + sp->stream.msg); return (0); } } while (sp->stream.avail_out > 0); @@ -757,8 +788,8 @@ PixarLogDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) /* hopefully, we got all the bytes we needed */ if (sp->stream.avail_out != 0) { TIFFErrorExt(tif->tif_clientdata, module, - "%s: Not enough data at scanline %d (short %d bytes)", - tif->tif_name, tif->tif_row, sp->stream.avail_out); + "Not enough data at scanline %lu (short " TIFF_UINT64_FORMAT " bytes)", + (unsigned long) tif->tif_row, (TIFF_UINT64_T) sp->stream.avail_out); return (0); } @@ -767,15 +798,15 @@ PixarLogDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) if (tif->tif_flags & TIFF_SWAB) TIFFSwabArrayOfShort(up, nsamples); - /* + /* * if llen is not an exact multiple of nsamples, the decode operation * may overflow the output buffer, so truncate it enough to prevent * that but still salvage as much data as possible. */ if (nsamples % llen) { TIFFWarningExt(tif->tif_clientdata, module, - "%s: stride %d is not a multiple of sample count, " - "%d, data truncated.", tif->tif_name, llen, nsamples); + "stride %lu is not a multiple of sample count, " + "%lu, data truncated.", (unsigned long) llen, (unsigned long) nsamples); nsamples -= nsamples % llen; } @@ -812,8 +843,8 @@ PixarLogDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) op += llen * sizeof(unsigned char); break; default: - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "PixarLogDecode: unsupported bits/sample: %d", + TIFFErrorExt(tif->tif_clientdata, module, + "Unsupported bits/sample: %d", td->td_bitspersample); return (0); } @@ -825,10 +856,10 @@ PixarLogDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) static int PixarLogSetupEncode(TIFF* tif) { + static const char module[] = "PixarLogSetupEncode"; TIFFDirectory *td = &tif->tif_dir; PixarLogState* sp = EncoderState(tif); - tsize_t tbuf_size; - static const char module[] = "PixarLogSetupEncode"; + tmsize_t tbuf_size; assert(sp != NULL); @@ -836,10 +867,10 @@ PixarLogSetupEncode(TIFF* tif) sp->stride = (td->td_planarconfig == PLANARCONFIG_CONTIG ? td->td_samplesperpixel : 1); - tbuf_size = multiply(multiply(multiply(sp->stride, td->td_imagewidth), + tbuf_size = multiply_ms(multiply_ms(multiply_ms(sp->stride, td->td_imagewidth), td->td_rowsperstrip), sizeof(uint16)); if (tbuf_size == 0) - return (0); + return (0); /* TODO: this is an error return without error report through TIFFErrorExt */ sp->tbuf = (uint16 *) _TIFFmalloc(tbuf_size); if (sp->tbuf == NULL) return (0); @@ -851,7 +882,7 @@ PixarLogSetupEncode(TIFF* tif) } if (deflateInit(&sp->stream, sp->quality) != Z_OK) { - TIFFErrorExt(tif->tif_clientdata, module, "%s: %s", tif->tif_name, sp->stream.msg); + TIFFErrorExt(tif->tif_clientdata, module, "%s", sp->stream.msg); return (0); } else { sp->state |= PLSTATE_INIT; @@ -863,21 +894,30 @@ PixarLogSetupEncode(TIFF* tif) * Reset encoding state at the start of a strip. */ static int -PixarLogPreEncode(TIFF* tif, tsample_t s) +PixarLogPreEncode(TIFF* tif, uint16 s) { + static const char module[] = "PixarLogPreEncode"; PixarLogState *sp = EncoderState(tif); (void) s; assert(sp != NULL); sp->stream.next_out = tif->tif_rawdata; + assert(sizeof(sp->stream.avail_out)==4); /* if this assert gets raised, + we need to simplify this code to reflect a ZLib that is likely updated + to deal with 8byte memory sizes, though this code will respond + apropriately even before we simplify it */ sp->stream.avail_out = tif->tif_rawdatasize; + if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize) + { + TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size"); + return (0); + } return (deflateReset(&sp->stream) == Z_OK); } static void horizontalDifferenceF(float *ip, int n, int stride, uint16 *wp, uint16 *FromLT2) { - int32 r1, g1, b1, a1, r2, g2, b2, a2, mask; float fltsize = Fltsize; @@ -1042,12 +1082,14 @@ horizontalDifference8(unsigned char *ip, int n, int stride, * Encode a chunk of pixels. */ static int -PixarLogEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) +PixarLogEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s) { + static const char module[] = "PixarLogEncode"; TIFFDirectory *td = &tif->tif_dir; PixarLogState *sp = EncoderState(tif); - static const char module[] = "PixarLogEncode"; - int i, n, llen; + tmsize_t i; + tmsize_t n; + int llen; unsigned short * up; (void) s; @@ -1066,7 +1108,7 @@ PixarLogEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) n = cc; break; default: - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, + TIFFErrorExt(tif->tif_clientdata, module, "%d bit input not supported in PixarLog", td->td_bitspersample); return 0; @@ -1092,7 +1134,7 @@ PixarLogEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) bp += llen * sizeof(unsigned char); break; default: - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, + TIFFErrorExt(tif->tif_clientdata, module, "%d bit input not supported in PixarLog", td->td_bitspersample); return 0; @@ -1100,19 +1142,29 @@ PixarLogEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) } sp->stream.next_in = (unsigned char *) sp->tbuf; - sp->stream.avail_in = n * sizeof(uint16); + assert(sizeof(sp->stream.avail_in)==4); /* if this assert gets raised, + we need to simplify this code to reflect a ZLib that is likely updated + to deal with 8byte memory sizes, though this code will respond + apropriately even before we simplify it */ + sp->stream.avail_in = (uInt) (n * sizeof(uint16)); + if ((sp->stream.avail_in / sizeof(uint16)) != (uInt) n) + { + TIFFErrorExt(tif->tif_clientdata, module, + "ZLib cannot deal with buffers this size"); + return (0); + } do { if (deflate(&sp->stream, Z_NO_FLUSH) != Z_OK) { - TIFFErrorExt(tif->tif_clientdata, module, "%s: Encoder error: %s", - tif->tif_name, sp->stream.msg); + TIFFErrorExt(tif->tif_clientdata, module, "Encoder error: %s", + sp->stream.msg); return (0); } if (sp->stream.avail_out == 0) { tif->tif_rawcc = tif->tif_rawdatasize; TIFFFlushData1(tif); sp->stream.next_out = tif->tif_rawdata; - sp->stream.avail_out = tif->tif_rawdatasize; + sp->stream.avail_out = (uInt) tif->tif_rawdatasize; /* this is a safe typecast, as check is made already in PixarLogPreEncode */ } } while (sp->stream.avail_in > 0); return (1); @@ -1126,8 +1178,8 @@ PixarLogEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) static int PixarLogPostEncode(TIFF* tif) { - PixarLogState *sp = EncoderState(tif); static const char module[] = "PixarLogPostEncode"; + PixarLogState *sp = EncoderState(tif); int state; sp->stream.avail_in = 0; @@ -1137,17 +1189,17 @@ PixarLogPostEncode(TIFF* tif) switch (state) { case Z_STREAM_END: case Z_OK: - if (sp->stream.avail_out != (uint32)tif->tif_rawdatasize) { + if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize) { tif->tif_rawcc = tif->tif_rawdatasize - sp->stream.avail_out; TIFFFlushData1(tif); sp->stream.next_out = tif->tif_rawdata; - sp->stream.avail_out = tif->tif_rawdatasize; + sp->stream.avail_out = (uInt) tif->tif_rawdatasize; /* this is a safe typecast, as check is made already in PixarLogPreEncode */ } break; default: - TIFFErrorExt(tif->tif_clientdata, module, "%s: zlib error: %s", - tif->tif_name, sp->stream.msg); + TIFFErrorExt(tif->tif_clientdata, module, "ZLib error: %s", + sp->stream.msg); return (0); } } while (state != Z_STREAM_END); @@ -1159,9 +1211,11 @@ PixarLogClose(TIFF* tif) { TIFFDirectory *td = &tif->tif_dir; - /* In a really sneaky maneuver, on close, we covertly modify both - * bitspersample and sampleformat in the directory to indicate - * 8-bit linear. This way, the decode "just works" even for + /* In a really sneaky (and really incorrect, and untruthfull, and + * troublesome, and error-prone) maneuver that completely goes against + * the spirit of TIFF, and breaks TIFF, on close, we covertly + * modify both bitspersample and sampleformat in the directory to + * indicate 8-bit linear. This way, the decode "just works" even for * readers that don't know about PixarLog, or how to set * the PIXARLOGDATFMT pseudo-tag. */ @@ -1202,26 +1256,26 @@ PixarLogCleanup(TIFF* tif) } static int -PixarLogVSetField(TIFF* tif, ttag_t tag, va_list ap) +PixarLogVSetField(TIFF* tif, uint32 tag, va_list ap) { + static const char module[] = "PixarLogVSetField"; PixarLogState *sp = (PixarLogState *)tif->tif_data; int result; - static const char module[] = "PixarLogVSetField"; switch (tag) { case TIFFTAG_PIXARLOGQUALITY: - sp->quality = va_arg(ap, int); + sp->quality = (int) va_arg(ap, int); if (tif->tif_mode != O_RDONLY && (sp->state&PLSTATE_INIT)) { if (deflateParams(&sp->stream, sp->quality, Z_DEFAULT_STRATEGY) != Z_OK) { - TIFFErrorExt(tif->tif_clientdata, module, "%s: zlib error: %s", - tif->tif_name, sp->stream.msg); + TIFFErrorExt(tif->tif_clientdata, module, "ZLib error: %s", + sp->stream.msg); return (0); } } return (1); case TIFFTAG_PIXARLOGDATAFMT: - sp->user_datafmt = va_arg(ap, int); + sp->user_datafmt = (int) va_arg(ap, int); /* Tweak the TIFF header so that the rest of libtiff knows what * size of data will be passed between app and library, and * assume that the app knows what it is doing and is not @@ -1253,7 +1307,7 @@ PixarLogVSetField(TIFF* tif, ttag_t tag, va_list ap) /* * Must recalculate sizes should bits/sample change. */ - tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tsize_t) -1; + tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tmsize_t)(-1); tif->tif_scanlinesize = TIFFScanlineSize(tif); result = 1; /* NB: pseudo tag */ break; @@ -1264,7 +1318,7 @@ PixarLogVSetField(TIFF* tif, ttag_t tag, va_list ap) } static int -PixarLogVGetField(TIFF* tif, ttag_t tag, va_list ap) +PixarLogVGetField(TIFF* tif, uint32 tag, va_list ap) { PixarLogState *sp = (PixarLogState *)tif->tif_data; @@ -1281,9 +1335,9 @@ PixarLogVGetField(TIFF* tif, ttag_t tag, va_list ap) return (1); } -static const TIFFFieldInfo pixarlogFieldInfo[] = { - {TIFFTAG_PIXARLOGDATAFMT,0,0,TIFF_ANY, FIELD_PSEUDO,FALSE,FALSE,""}, - {TIFFTAG_PIXARLOGQUALITY,0,0,TIFF_ANY, FIELD_PSEUDO,FALSE,FALSE,""} +static const TIFFField pixarlogFields[] = { + {TIFFTAG_PIXARLOGDATAFMT, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE, "", NULL}, + {TIFFTAG_PIXARLOGQUALITY, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE, "", NULL} }; int @@ -1298,8 +1352,8 @@ TIFFInitPixarLog(TIFF* tif, int scheme) /* * Merge codec-specific tag information. */ - if (!_TIFFMergeFieldInfo(tif, pixarlogFieldInfo, - TIFFArrayCount(pixarlogFieldInfo))) { + if (!_TIFFMergeFields(tif, pixarlogFields, + TIFFArrayCount(pixarlogFields))) { TIFFErrorExt(tif->tif_clientdata, module, "Merging PixarLog codec-specific tags failed"); return 0; @@ -1308,7 +1362,7 @@ TIFFInitPixarLog(TIFF* tif, int scheme) /* * Allocate state block so tag methods have storage to record values. */ - tif->tif_data = (tidata_t) _TIFFmalloc(sizeof (PixarLogState)); + tif->tif_data = (uint8*) _TIFFmalloc(sizeof (PixarLogState)); if (tif->tif_data == NULL) goto bad; sp = (PixarLogState*) tif->tif_data; @@ -1319,17 +1373,18 @@ TIFFInitPixarLog(TIFF* tif, int scheme) /* * Install codec methods. */ + tif->tif_fixuptags = PixarLogFixupTags; tif->tif_setupdecode = PixarLogSetupDecode; tif->tif_predecode = PixarLogPreDecode; tif->tif_decoderow = PixarLogDecode; - tif->tif_decodestrip = PixarLogDecode; + tif->tif_decodestrip = PixarLogDecode; tif->tif_decodetile = PixarLogDecode; tif->tif_setupencode = PixarLogSetupEncode; tif->tif_preencode = PixarLogPreEncode; tif->tif_postencode = PixarLogPostEncode; - tif->tif_encoderow = PixarLogEncode; + tif->tif_encoderow = PixarLogEncode; tif->tif_encodestrip = PixarLogEncode; - tif->tif_encodetile = PixarLogEncode; + tif->tif_encodetile = PixarLogEncode; tif->tif_close = PixarLogClose; tif->tif_cleanup = PixarLogCleanup; @@ -1362,3 +1417,10 @@ bad: #endif /* PIXARLOG_SUPPORT */ /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_predict.c b/src/3rdparty/libtiff/libtiff/tif_predict.c index 052a8e2..f93c664 100644 --- a/src/3rdparty/libtiff/libtiff/tif_predict.c +++ b/src/3rdparty/libtiff/libtiff/tif_predict.c @@ -1,4 +1,4 @@ -/* $Id: tif_predict.c,v 1.11.2.3 2009-01-23 15:57:18 fwarmerdam Exp $ */ +/* $Id: tif_predict.c,v 1.32 2010-03-10 18:56:49 bfriesen Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler @@ -34,20 +34,20 @@ #define PredictorState(tif) ((TIFFPredictorState*) (tif)->tif_data) -static void horAcc8(TIFF*, tidata_t, tsize_t); -static void horAcc16(TIFF*, tidata_t, tsize_t); -static void horAcc32(TIFF*, tidata_t, tsize_t); -static void swabHorAcc16(TIFF*, tidata_t, tsize_t); -static void swabHorAcc32(TIFF*, tidata_t, tsize_t); -static void horDiff8(TIFF*, tidata_t, tsize_t); -static void horDiff16(TIFF*, tidata_t, tsize_t); -static void horDiff32(TIFF*, tidata_t, tsize_t); -static void fpAcc(TIFF*, tidata_t, tsize_t); -static void fpDiff(TIFF*, tidata_t, tsize_t); -static int PredictorDecodeRow(TIFF*, tidata_t, tsize_t, tsample_t); -static int PredictorDecodeTile(TIFF*, tidata_t, tsize_t, tsample_t); -static int PredictorEncodeRow(TIFF*, tidata_t, tsize_t, tsample_t); -static int PredictorEncodeTile(TIFF*, tidata_t, tsize_t, tsample_t); +static void horAcc8(TIFF* tif, uint8* cp0, tmsize_t cc); +static void horAcc16(TIFF* tif, uint8* cp0, tmsize_t cc); +static void horAcc32(TIFF* tif, uint8* cp0, tmsize_t cc); +static void swabHorAcc16(TIFF* tif, uint8* cp0, tmsize_t cc); +static void swabHorAcc32(TIFF* tif, uint8* cp0, tmsize_t cc); +static void horDiff8(TIFF* tif, uint8* cp0, tmsize_t cc); +static void horDiff16(TIFF* tif, uint8* cp0, tmsize_t cc); +static void horDiff32(TIFF* tif, uint8* cp0, tmsize_t cc); +static void fpAcc(TIFF* tif, uint8* cp0, tmsize_t cc); +static void fpDiff(TIFF* tif, uint8* cp0, tmsize_t cc); +static int PredictorDecodeRow(TIFF* tif, uint8* op0, tmsize_t occ0, uint16 s); +static int PredictorDecodeTile(TIFF* tif, uint8* op0, tmsize_t occ0, uint16 s); +static int PredictorEncodeRow(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s); +static int PredictorEncodeTile(TIFF* tif, uint8* bp0, tmsize_t cc0, uint16 s); static int PredictorSetup(TIFF* tif) @@ -66,23 +66,23 @@ PredictorSetup(TIFF* tif) && td->td_bitspersample != 16 && td->td_bitspersample != 32) { TIFFErrorExt(tif->tif_clientdata, module, - "Horizontal differencing \"Predictor\" not supported with %d-bit samples", - td->td_bitspersample); + "Horizontal differencing \"Predictor\" not supported with %d-bit samples", + td->td_bitspersample); return 0; } break; case PREDICTOR_FLOATINGPOINT: if (td->td_sampleformat != SAMPLEFORMAT_IEEEFP) { TIFFErrorExt(tif->tif_clientdata, module, - "Floating point \"Predictor\" not supported with %d data format", - td->td_sampleformat); + "Floating point \"Predictor\" not supported with %d data format", + td->td_sampleformat); return 0; } break; default: TIFFErrorExt(tif->tif_clientdata, module, - "\"Predictor\" value %d not supported", - sp->predictor); + "\"Predictor\" value %d not supported", + sp->predictor); return 0; } sp->stride = (td->td_planarconfig == PLANARCONFIG_CONTIG ? @@ -94,6 +94,8 @@ PredictorSetup(TIFF* tif) sp->rowsize = TIFFTileRowSize(tif); else sp->rowsize = TIFFScanlineSize(tif); + if (sp->rowsize == 0) + return 0; return 1; } @@ -126,6 +128,7 @@ PredictorSetupDecode(TIFF* tif) sp->decodetile = tif->tif_decodetile; tif->tif_decodetile = PredictorDecodeTile; } + /* * If the data is horizontally differenced 16-bit data that * requires byte-swapping, then it must be byte swapped before @@ -137,10 +140,10 @@ PredictorSetupDecode(TIFF* tif) if (sp->decodepfunc == horAcc16) { sp->decodepfunc = swabHorAcc16; tif->tif_postdecode = _TIFFNoPostDecode; - } else if (sp->decodepfunc == horAcc32) { + } else if (sp->decodepfunc == horAcc32) { sp->decodepfunc = swabHorAcc32; tif->tif_postdecode = _TIFFNoPostDecode; - } + } } } @@ -205,7 +208,7 @@ PredictorSetupEncode(TIFF* tif) tif->tif_encodetile = PredictorEncodeTile; } } - + else if (sp->predictor == 3) { sp->encodepfunc = fpDiff; /* @@ -228,7 +231,7 @@ PredictorSetupEncode(TIFF* tif) #define REPEAT4(n, op) \ switch (n) { \ - default: { int i; for (i = n-4; i > 0; i--) { op; } } \ + default: { tmsize_t i; for (i = n-4; i > 0; i--) { op; } } \ case 4: op; \ case 3: op; \ case 2: op; \ @@ -237,13 +240,13 @@ PredictorSetupEncode(TIFF* tif) } static void -horAcc8(TIFF* tif, tidata_t cp0, tsize_t cc) +horAcc8(TIFF* tif, uint8* cp0, tmsize_t cc) { - tsize_t stride = PredictorState(tif)->stride; + tmsize_t stride = PredictorState(tif)->stride; char* cp = (char*) cp0; + assert((cc%stride)==0); if (cc > stride) { - cc -= stride; /* * Pipeline the most common cases. */ @@ -251,40 +254,49 @@ horAcc8(TIFF* tif, tidata_t cp0, tsize_t cc) unsigned int cr = cp[0]; unsigned int cg = cp[1]; unsigned int cb = cp[2]; - do { - cc -= 3, cp += 3; + cc -= 3; + cp += 3; + while (cc>0) { cp[0] = (char) (cr += cp[0]); cp[1] = (char) (cg += cp[1]); cp[2] = (char) (cb += cp[2]); - } while ((int32) cc > 0); + cc -= 3; + cp += 3; + } } else if (stride == 4) { unsigned int cr = cp[0]; unsigned int cg = cp[1]; unsigned int cb = cp[2]; unsigned int ca = cp[3]; - do { - cc -= 4, cp += 4; + cc -= 4; + cp += 4; + while (cc>0) { cp[0] = (char) (cr += cp[0]); cp[1] = (char) (cg += cp[1]); cp[2] = (char) (cb += cp[2]); cp[3] = (char) (ca += cp[3]); - } while ((int32) cc > 0); + cc -= 4; + cp += 4; + } } else { + cc -= stride; do { REPEAT4(stride, cp[stride] = (char) (cp[stride] + *cp); cp++) cc -= stride; - } while ((int32) cc > 0); + } while (cc>0); } } } static void -swabHorAcc16(TIFF* tif, tidata_t cp0, tsize_t cc) +swabHorAcc16(TIFF* tif, uint8* cp0, tmsize_t cc) { - tsize_t stride = PredictorState(tif)->stride; + tmsize_t stride = PredictorState(tif)->stride; uint16* wp = (uint16*) cp0; - tsize_t wc = cc / 2; + tmsize_t wc = cc / 2; + + assert((cc%(2*stride))==0); if (wc > stride) { TIFFSwabArrayOfShort(wp, wc); @@ -292,32 +304,36 @@ swabHorAcc16(TIFF* tif, tidata_t cp0, tsize_t cc) do { REPEAT4(stride, wp[stride] += wp[0]; wp++) wc -= stride; - } while ((int32) wc > 0); + } while (wc > 0); } } static void -horAcc16(TIFF* tif, tidata_t cp0, tsize_t cc) +horAcc16(TIFF* tif, uint8* cp0, tmsize_t cc) { - tsize_t stride = PredictorState(tif)->stride; + tmsize_t stride = PredictorState(tif)->stride; uint16* wp = (uint16*) cp0; - tsize_t wc = cc / 2; + tmsize_t wc = cc / 2; + + assert((cc%(2*stride))==0); if (wc > stride) { wc -= stride; do { REPEAT4(stride, wp[stride] += wp[0]; wp++) wc -= stride; - } while ((int32) wc > 0); + } while (wc > 0); } } static void -swabHorAcc32(TIFF* tif, tidata_t cp0, tsize_t cc) +swabHorAcc32(TIFF* tif, uint8* cp0, tmsize_t cc) { - tsize_t stride = PredictorState(tif)->stride; + tmsize_t stride = PredictorState(tif)->stride; uint32* wp = (uint32*) cp0; - tsize_t wc = cc / 4; + tmsize_t wc = cc / 4; + + assert((cc%(4*stride))==0); if (wc > stride) { TIFFSwabArrayOfLong(wp, wc); @@ -325,23 +341,25 @@ swabHorAcc32(TIFF* tif, tidata_t cp0, tsize_t cc) do { REPEAT4(stride, wp[stride] += wp[0]; wp++) wc -= stride; - } while ((int32) wc > 0); + } while (wc > 0); } } static void -horAcc32(TIFF* tif, tidata_t cp0, tsize_t cc) +horAcc32(TIFF* tif, uint8* cp0, tmsize_t cc) { - tsize_t stride = PredictorState(tif)->stride; + tmsize_t stride = PredictorState(tif)->stride; uint32* wp = (uint32*) cp0; - tsize_t wc = cc / 4; + tmsize_t wc = cc / 4; + + assert((cc%(4*stride))==0); if (wc > stride) { wc -= stride; do { REPEAT4(stride, wp[stride] += wp[0]; wp++) wc -= stride; - } while ((int32) wc > 0); + } while (wc > 0); } } @@ -349,15 +367,17 @@ horAcc32(TIFF* tif, tidata_t cp0, tsize_t cc) * Floating point predictor accumulation routine. */ static void -fpAcc(TIFF* tif, tidata_t cp0, tsize_t cc) +fpAcc(TIFF* tif, uint8* cp0, tmsize_t cc) { - tsize_t stride = PredictorState(tif)->stride; + tmsize_t stride = PredictorState(tif)->stride; uint32 bps = tif->tif_dir.td_bitspersample / 8; - tsize_t wc = cc / bps; - tsize_t count = cc; + tmsize_t wc = cc / bps; + tmsize_t count = cc; uint8 *cp = (uint8 *) cp0; uint8 *tmp = (uint8 *)_TIFFmalloc(cc); + assert((cc%(bps*stride))==0); + if (!tmp) return; @@ -371,12 +391,12 @@ fpAcc(TIFF* tif, tidata_t cp0, tsize_t cc) for (count = 0; count < wc; count++) { uint32 byte; for (byte = 0; byte < bps; byte++) { -#if WORDS_BIGENDIAN + #if WORDS_BIGENDIAN cp[bps * count + byte] = tmp[byte * wc + count]; -#else + #else cp[bps * count + byte] = tmp[(bps - byte - 1) * wc + count]; -#endif + #endif } } _TIFFfree(tmp); @@ -386,13 +406,13 @@ fpAcc(TIFF* tif, tidata_t cp0, tsize_t cc) * Decode a scanline and apply the predictor routine. */ static int -PredictorDecodeRow(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) +PredictorDecodeRow(TIFF* tif, uint8* op0, tmsize_t occ0, uint16 s) { TIFFPredictorState *sp = PredictorState(tif); assert(sp != NULL); assert(sp->decoderow != NULL); - assert(sp->decodepfunc != NULL); + assert(sp->decodepfunc != NULL); if ((*sp->decoderow)(tif, op0, occ0, s)) { (*sp->decodepfunc)(tif, op0, occ0); @@ -409,7 +429,7 @@ PredictorDecodeRow(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) * strip/tile dimensions. */ static int -PredictorDecodeTile(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) +PredictorDecodeTile(TIFF* tif, uint8* op0, tmsize_t occ0, uint16 s) { TIFFPredictorState *sp = PredictorState(tif); @@ -417,11 +437,12 @@ PredictorDecodeTile(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) assert(sp->decodetile != NULL); if ((*sp->decodetile)(tif, op0, occ0, s)) { - tsize_t rowsize = sp->rowsize; + tmsize_t rowsize = sp->rowsize; assert(rowsize > 0); + assert((occ0%rowsize)==0); assert(sp->decodepfunc != NULL); - while ((long)occ0 > 0) { - (*sp->decodepfunc)(tif, op0, (tsize_t) rowsize); + while (occ0 > 0) { + (*sp->decodepfunc)(tif, op0, rowsize); occ0 -= rowsize; op0 += rowsize; } @@ -431,12 +452,14 @@ PredictorDecodeTile(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) } static void -horDiff8(TIFF* tif, tidata_t cp0, tsize_t cc) +horDiff8(TIFF* tif, uint8* cp0, tmsize_t cc) { TIFFPredictorState* sp = PredictorState(tif); - tsize_t stride = sp->stride; + tmsize_t stride = sp->stride; char* cp = (char*) cp0; + assert((cc%stride)==0); + if (cc > stride) { cc -= stride; /* @@ -452,7 +475,7 @@ horDiff8(TIFF* tif, tidata_t cp0, tsize_t cc) g1 = cp[4]; cp[4] = g1-g2; g2 = g1; b1 = cp[5]; cp[5] = b1-b2; b2 = b1; cp += 3; - } while ((int32)(cc -= 3) > 0); + } while ((cc -= 3) > 0); } else if (stride == 4) { int r1, g1, b1, a1; int r2 = cp[0]; @@ -465,23 +488,25 @@ horDiff8(TIFF* tif, tidata_t cp0, tsize_t cc) b1 = cp[6]; cp[6] = b1-b2; b2 = b1; a1 = cp[7]; cp[7] = a1-a2; a2 = a1; cp += 4; - } while ((int32)(cc -= 4) > 0); + } while ((cc -= 4) > 0); } else { cp += cc - 1; do { REPEAT4(stride, cp[stride] -= cp[0]; cp--) - } while ((int32)(cc -= stride) > 0); + } while ((cc -= stride) > 0); } } } static void -horDiff16(TIFF* tif, tidata_t cp0, tsize_t cc) +horDiff16(TIFF* tif, uint8* cp0, tmsize_t cc) { TIFFPredictorState* sp = PredictorState(tif); - tsize_t stride = sp->stride; + tmsize_t stride = sp->stride; int16 *wp = (int16*) cp0; - tsize_t wc = cc/2; + tmsize_t wc = cc/2; + + assert((cc%(2*stride))==0); if (wc > stride) { wc -= stride; @@ -489,17 +514,19 @@ horDiff16(TIFF* tif, tidata_t cp0, tsize_t cc) do { REPEAT4(stride, wp[stride] -= wp[0]; wp--) wc -= stride; - } while ((int32) wc > 0); + } while (wc > 0); } } static void -horDiff32(TIFF* tif, tidata_t cp0, tsize_t cc) +horDiff32(TIFF* tif, uint8* cp0, tmsize_t cc) { TIFFPredictorState* sp = PredictorState(tif); - tsize_t stride = sp->stride; + tmsize_t stride = sp->stride; int32 *wp = (int32*) cp0; - tsize_t wc = cc/4; + tmsize_t wc = cc/4; + + assert((cc%(4*stride))==0); if (wc > stride) { wc -= stride; @@ -507,7 +534,7 @@ horDiff32(TIFF* tif, tidata_t cp0, tsize_t cc) do { REPEAT4(stride, wp[stride] -= wp[0]; wp--) wc -= stride; - } while ((int32) wc > 0); + } while (wc > 0); } } @@ -515,15 +542,17 @@ horDiff32(TIFF* tif, tidata_t cp0, tsize_t cc) * Floating point predictor differencing routine. */ static void -fpDiff(TIFF* tif, tidata_t cp0, tsize_t cc) +fpDiff(TIFF* tif, uint8* cp0, tmsize_t cc) { - tsize_t stride = PredictorState(tif)->stride; + tmsize_t stride = PredictorState(tif)->stride; uint32 bps = tif->tif_dir.td_bitspersample / 8; - tsize_t wc = cc / bps; - tsize_t count; + tmsize_t wc = cc / bps; + tmsize_t count; uint8 *cp = (uint8 *) cp0; uint8 *tmp = (uint8 *)_TIFFmalloc(cc); + assert((cc%(bps*stride))==0); + if (!tmp) return; @@ -531,12 +560,12 @@ fpDiff(TIFF* tif, tidata_t cp0, tsize_t cc) for (count = 0; count < wc; count++) { uint32 byte; for (byte = 0; byte < bps; byte++) { -#if WORDS_BIGENDIAN - cp[byte * wc + count] = tmp[bps * count + byte]; -#else + #if WORDS_BIGENDIAN + cp[byte * wc + count] = tmp[bps * count + byte]; + #else cp[(bps - byte - 1) * wc + count] = tmp[bps * count + byte]; -#endif + #endif } } _TIFFfree(tmp); @@ -548,7 +577,7 @@ fpDiff(TIFF* tif, tidata_t cp0, tsize_t cc) } static int -PredictorEncodeRow(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) +PredictorEncodeRow(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s) { TIFFPredictorState *sp = PredictorState(tif); @@ -562,12 +591,12 @@ PredictorEncodeRow(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) } static int -PredictorEncodeTile(TIFF* tif, tidata_t bp0, tsize_t cc0, tsample_t s) +PredictorEncodeTile(TIFF* tif, uint8* bp0, tmsize_t cc0, uint16 s) { static const char module[] = "PredictorEncodeTile"; TIFFPredictorState *sp = PredictorState(tif); uint8 *working_copy; - tsize_t cc = cc0, rowsize; + tmsize_t cc = cc0, rowsize; unsigned char* bp; int result_code; @@ -583,7 +612,7 @@ PredictorEncodeTile(TIFF* tif, tidata_t bp0, tsize_t cc0, tsample_t s) if( working_copy == NULL ) { TIFFErrorExt(tif->tif_clientdata, module, - "Out of memory allocating %d byte temp buffer.", + "Out of memory allocating " TIFF_SSIZE_FORMAT " byte temp buffer.", cc0 ); return 0; } @@ -607,13 +636,12 @@ PredictorEncodeTile(TIFF* tif, tidata_t bp0, tsize_t cc0, tsample_t s) #define FIELD_PREDICTOR (FIELD_CODEC+0) /* XXX */ -static const TIFFFieldInfo predictFieldInfo[] = { - { TIFFTAG_PREDICTOR, 1, 1, TIFF_SHORT, FIELD_PREDICTOR, - FALSE, FALSE, "Predictor" }, +static const TIFFField predictFields[] = { + { TIFFTAG_PREDICTOR, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UINT16, FIELD_PREDICTOR, FALSE, FALSE, "Predictor", NULL }, }; static int -PredictorVSetField(TIFF* tif, ttag_t tag, va_list ap) +PredictorVSetField(TIFF* tif, uint32 tag, va_list ap) { TIFFPredictorState *sp = PredictorState(tif); @@ -622,7 +650,7 @@ PredictorVSetField(TIFF* tif, ttag_t tag, va_list ap) switch (tag) { case TIFFTAG_PREDICTOR: - sp->predictor = (uint16) va_arg(ap, int); + sp->predictor = (uint16) va_arg(ap, uint16_vap); TIFFSetFieldBit(tif, FIELD_PREDICTOR); break; default: @@ -633,7 +661,7 @@ PredictorVSetField(TIFF* tif, ttag_t tag, va_list ap) } static int -PredictorVGetField(TIFF* tif, ttag_t tag, va_list ap) +PredictorVGetField(TIFF* tif, uint32 tag, va_list ap) { TIFFPredictorState *sp = PredictorState(tif); @@ -659,9 +687,9 @@ PredictorPrintDir(TIFF* tif, FILE* fd, long flags) if (TIFFFieldSet(tif,FIELD_PREDICTOR)) { fprintf(fd, " Predictor: "); switch (sp->predictor) { - case 1: fprintf(fd, "none "); break; - case 2: fprintf(fd, "horizontal differencing "); break; - case 3: fprintf(fd, "floating point predictor "); break; + case 1: fprintf(fd, "none "); break; + case 2: fprintf(fd, "horizontal differencing "); break; + case 3: fprintf(fd, "floating point predictor "); break; } fprintf(fd, "%u (0x%x)\n", sp->predictor, sp->predictor); } @@ -679,10 +707,10 @@ TIFFPredictorInit(TIFF* tif) /* * Merge codec-specific tag information. */ - if (!_TIFFMergeFieldInfo(tif, predictFieldInfo, - TIFFArrayCount(predictFieldInfo))) { + if (!_TIFFMergeFields(tif, predictFields, + TIFFArrayCount(predictFields))) { TIFFErrorExt(tif->tif_clientdata, "TIFFPredictorInit", - "Merging Predictor codec-specific tags failed"); + "Merging Predictor codec-specific tags failed"); return 0; } @@ -694,7 +722,7 @@ TIFFPredictorInit(TIFF* tif) PredictorVGetField;/* hook for predictor tag */ sp->vsetparent = tif->tif_tagmethods.vsetfield; tif->tif_tagmethods.vsetfield = - PredictorVSetField;/* hook for predictor tag */ + PredictorVSetField;/* hook for predictor tag */ sp->printdir = tif->tif_tagmethods.printdir; tif->tif_tagmethods.printdir = PredictorPrintDir; /* hook for predictor tag */ @@ -727,3 +755,10 @@ TIFFPredictorCleanup(TIFF* tif) } /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_predict.h b/src/3rdparty/libtiff/libtiff/tif_predict.h index 0c1aefc..dc7144c 100644 --- a/src/3rdparty/libtiff/libtiff/tif_predict.h +++ b/src/3rdparty/libtiff/libtiff/tif_predict.h @@ -1,26 +1,26 @@ -/* $Id: tif_predict.h,v 1.3.2.1 2007/11/22 21:24:51 fwarmerdam Exp $ */ +/* $Id: tif_predict.h,v 1.8 2010-03-10 18:56:49 bfriesen Exp $ */ /* * Copyright (c) 1995-1997 Sam Leffler * Copyright (c) 1995-1997 Silicon Graphics, Inc. * - * Permission to use, copy, modify, distribute, and sell this software and + * 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. - * + * + * 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 + * 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. */ @@ -36,35 +36,42 @@ * the predictor code can cast tif_data to find its state. */ typedef struct { - int predictor; /* predictor tag value */ - int stride; /* sample stride over data */ - tsize_t rowsize; /* tile/strip row size */ + int predictor; /* predictor tag value */ + tmsize_t stride; /* sample stride over data */ + tmsize_t rowsize; /* tile/strip row size */ + + TIFFCodeMethod encoderow; /* parent codec encode/decode row */ + TIFFCodeMethod encodestrip; /* parent codec encode/decode strip */ + TIFFCodeMethod encodetile; /* parent codec encode/decode tile */ + TIFFPostMethod encodepfunc; /* horizontal differencer */ - TIFFCodeMethod encoderow; /* parent codec encode/decode row */ - TIFFCodeMethod encodestrip; /* parent codec encode/decode strip */ - TIFFCodeMethod encodetile; /* parent codec encode/decode tile */ - TIFFPostMethod encodepfunc; /* horizontal differencer */ - - TIFFCodeMethod decoderow; /* parent codec encode/decode row */ - TIFFCodeMethod decodestrip; /* parent codec encode/decode strip */ - TIFFCodeMethod decodetile; /* parent codec encode/decode tile */ - TIFFPostMethod decodepfunc; /* horizontal accumulator */ + TIFFCodeMethod decoderow; /* parent codec encode/decode row */ + TIFFCodeMethod decodestrip; /* parent codec encode/decode strip */ + TIFFCodeMethod decodetile; /* parent codec encode/decode tile */ + TIFFPostMethod decodepfunc; /* horizontal accumulator */ - TIFFVGetMethod vgetparent; /* super-class method */ - TIFFVSetMethod vsetparent; /* super-class method */ - TIFFPrintMethod printdir; /* super-class method */ - TIFFBoolMethod setupdecode; /* super-class method */ - TIFFBoolMethod setupencode; /* super-class method */ + TIFFVGetMethod vgetparent; /* super-class method */ + TIFFVSetMethod vsetparent; /* super-class method */ + TIFFPrintMethod printdir; /* super-class method */ + TIFFBoolMethod setupdecode; /* super-class method */ + TIFFBoolMethod setupencode; /* super-class method */ } TIFFPredictorState; #if defined(__cplusplus) extern "C" { #endif -extern int TIFFPredictorInit(TIFF*); -extern int TIFFPredictorCleanup(TIFF*); +extern int TIFFPredictorInit(TIFF*); +extern int TIFFPredictorCleanup(TIFF*); #if defined(__cplusplus) } #endif #endif /* _TIFFPREDICT_ */ /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_print.c b/src/3rdparty/libtiff/libtiff/tif_print.c index 871fffd..402666d 100644 --- a/src/3rdparty/libtiff/libtiff/tif_print.c +++ b/src/3rdparty/libtiff/libtiff/tif_print.c @@ -1,4 +1,4 @@ -/* $Id: tif_print.c,v 1.36.2.2 2009-09-17 18:00:28 bfriesen Exp $ */ +/* $Id: tif_print.c,v 1.60 2012-08-19 16:56:35 bfriesen Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler @@ -31,9 +31,12 @@ */ #include "tiffiop.h" #include <stdio.h> -#include <string.h> + #include <ctype.h> +static void +_TIFFprintAsciiBounded(FILE* fd, const char* cp, int max_chars); + static const char *photoNames[] = { "min-is-white", /* PHOTOMETRIC_MINISWHITE */ "min-is-black", /* PHOTOMETRIC_MINISBLACK */ @@ -44,6 +47,8 @@ static const char *photoNames[] = { "YCbCr", /* PHOTOMETRIC_YCBCR */ "7 (0x7)", "CIE L*a*b*", /* PHOTOMETRIC_CIELAB */ + "ICC L*a*b*", /* PHOTOMETRIC_ICCLAB */ + "ITU L*a*b*" /* PHOTOMETRIC_ITULAB */ }; #define NPHOTONAMES (sizeof (photoNames) / sizeof (photoNames[0])) @@ -61,7 +66,7 @@ static const char *orientNames[] = { #define NORIENTNAMES (sizeof (orientNames) / sizeof (orientNames[0])) static void -_TIFFPrintField(FILE* fd, const TIFFFieldInfo *fip, +_TIFFPrintField(FILE* fd, const TIFFField *fip, uint32 value_count, void *raw_data) { uint32 j; @@ -73,7 +78,7 @@ _TIFFPrintField(FILE* fd, const TIFFFieldInfo *fip, fprintf(fd, "%u", ((uint8 *) raw_data)[j]); else if(fip->field_type == TIFF_UNDEFINED) fprintf(fd, "0x%x", - (unsigned int) ((unsigned char *) raw_data)[j]); + (unsigned int) ((unsigned char *) raw_data)[j]); else if(fip->field_type == TIFF_SBYTE) fprintf(fd, "%d", ((int8 *) raw_data)[j]); else if(fip->field_type == TIFF_SHORT) @@ -82,23 +87,46 @@ _TIFFPrintField(FILE* fd, const TIFFFieldInfo *fip, fprintf(fd, "%d", ((int16 *) raw_data)[j]); else if(fip->field_type == TIFF_LONG) fprintf(fd, "%lu", - (unsigned long)((uint32 *) raw_data)[j]); + (unsigned long)((uint32 *) raw_data)[j]); else if(fip->field_type == TIFF_SLONG) fprintf(fd, "%ld", (long)((int32 *) raw_data)[j]); + else if(fip->field_type == TIFF_IFD) + fprintf(fd, "0x%lx", + (unsigned long)((uint32 *) raw_data)[j]); else if(fip->field_type == TIFF_RATIONAL || fip->field_type == TIFF_SRATIONAL || fip->field_type == TIFF_FLOAT) fprintf(fd, "%f", ((float *) raw_data)[j]); - else if(fip->field_type == TIFF_IFD) - fprintf(fd, "0x%ulx", ((uint32 *) raw_data)[j]); + else if(fip->field_type == TIFF_LONG8) +#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) + fprintf(fd, "%I64u", + (unsigned __int64)((uint64 *) raw_data)[j]); +#else + fprintf(fd, "%llu", + (unsigned long long)((uint64 *) raw_data)[j]); +#endif + else if(fip->field_type == TIFF_SLONG8) +#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) + fprintf(fd, "%I64d", (__int64)((int64 *) raw_data)[j]); +#else + fprintf(fd, "%lld", (long long)((int64 *) raw_data)[j]); +#endif + else if(fip->field_type == TIFF_IFD8) +#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) + fprintf(fd, "0x%I64x", + (unsigned __int64)((uint64 *) raw_data)[j]); +#else + fprintf(fd, "0x%llx", + (unsigned long long)((uint64 *) raw_data)[j]); +#endif + else if(fip->field_type == TIFF_FLOAT) + fprintf(fd, "%f", ((float *)raw_data)[j]); + else if(fip->field_type == TIFF_DOUBLE) + fprintf(fd, "%f", ((double *) raw_data)[j]); else if(fip->field_type == TIFF_ASCII) { fprintf(fd, "%s", (char *) raw_data); break; } - else if(fip->field_type == TIFF_DOUBLE) - fprintf(fd, "%f", ((double *) raw_data)[j]); - else if(fip->field_type == TIFF_FLOAT) - fprintf(fd, "%f", ((float *)raw_data)[j]); else { fprintf(fd, "<unsupported data type in TIFFPrint>"); break; @@ -112,16 +140,22 @@ _TIFFPrintField(FILE* fd, const TIFFFieldInfo *fip, } static int -_TIFFPrettyPrintField(TIFF* tif, FILE* fd, ttag_t tag, +_TIFFPrettyPrintField(TIFF* tif, const TIFFField *fip, FILE* fd, uint32 tag, uint32 value_count, void *raw_data) { - TIFFDirectory *td = &tif->tif_dir; + (void) tif; + /* do not try to pretty print auto-defined fields */ + if (strncmp(fip->field_name,"Tag ", 4) == 0) { + return 0; + } + switch (tag) { case TIFFTAG_INKSET: - fprintf(fd, " Ink Set: "); - switch (*((uint16*)raw_data)) { + if (value_count == 2 && fip->field_type == TIFF_SHORT) { + fprintf(fd, " Ink Set: "); + switch (*((uint16*)raw_data)) { case INKSET_CMYK: fprintf(fd, "CMYK\n"); break; @@ -130,30 +164,31 @@ _TIFFPrettyPrintField(TIFF* tif, FILE* fd, ttag_t tag, *((uint16*)raw_data), *((uint16*)raw_data)); break; + } + return 1; } - return 1; + return 0; + case TIFFTAG_DOTRANGE: - fprintf(fd, " Dot Range: %u-%u\n", - ((uint16*)raw_data)[0], ((uint16*)raw_data)[1]); - return 1; + if (value_count == 2 && fip->field_type == TIFF_SHORT) { + fprintf(fd, " Dot Range: %u-%u\n", + ((uint16*)raw_data)[0], ((uint16*)raw_data)[1]); + return 1; + } + return 0; + case TIFFTAG_WHITEPOINT: - fprintf(fd, " White Point: %g-%g\n", - ((float *)raw_data)[0], ((float *)raw_data)[1]); return 1; - case TIFFTAG_REFERENCEBLACKWHITE: - { - uint16 i; + if (value_count == 2 && fip->field_type == TIFF_RATIONAL) { + fprintf(fd, " White Point: %g-%g\n", + ((float *)raw_data)[0], ((float *)raw_data)[1]); + return 1; + } + return 0; - fprintf(fd, " Reference Black/White:\n"); - for (i = 0; i < td->td_samplesperpixel; i++) - fprintf(fd, " %2d: %5g %5g\n", i, - ((float *)raw_data)[2*i+0], - ((float *)raw_data)[2*i+1]); - return 1; - } case TIFFTAG_XMLPACKET: { uint32 i; - + fprintf(fd, " XMLPacket (XMP Metadata):\n" ); for(i = 0; i < value_count; i++) fputc(((char *)raw_data)[i], fd); @@ -166,23 +201,29 @@ _TIFFPrettyPrintField(TIFF* tif, FILE* fd, ttag_t tag, * defined as array of LONG values. */ fprintf(fd, - " RichTIFFIPTC Data: <present>, %lu bytes\n", - (unsigned long) value_count * 4); + " RichTIFFIPTC Data: <present>, %lu bytes\n", + (unsigned long) value_count * 4); return 1; + case TIFFTAG_PHOTOSHOP: fprintf(fd, " Photoshop Data: <present>, %lu bytes\n", - (unsigned long) value_count); + (unsigned long) value_count); return 1; + case TIFFTAG_ICCPROFILE: fprintf(fd, " ICC Profile: <present>, %lu bytes\n", - (unsigned long) value_count); + (unsigned long) value_count); return 1; + case TIFFTAG_STONITS: - fprintf(fd, - " Sample to Nits conversion factor: %.4e\n", - *((double*)raw_data)); - return 1; - } + if (value_count == 1 && fip->field_type == TIFF_DOUBLE) { + fprintf(fd, + " Sample to Nits conversion factor: %.4e\n", + *((double*)raw_data)); + return 1; + } + return 0; + } return 0; } @@ -199,8 +240,15 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags) uint16 i; long l, n; - fprintf(fd, "TIFF Directory at offset 0x%lx (%lu)\n", - (unsigned long)tif->tif_diroff, (unsigned long)tif->tif_diroff); +#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) + fprintf(fd, "TIFF Directory at offset 0x%I64x (%I64u)\n", + (unsigned __int64) tif->tif_diroff, + (unsigned __int64) tif->tif_diroff); +#else + fprintf(fd, "TIFF Directory at offset 0x%llx (%llu)\n", + (unsigned long long) tif->tif_diroff, + (unsigned long long) tif->tif_diroff); +#endif if (TIFFFieldSet(tif,FIELD_SUBFILETYPE)) { fprintf(fd, " Subfile Type:"); sep = " "; @@ -344,9 +392,13 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags) fprintf(fd, " Ink Names: "); i = td->td_samplesperpixel; sep = ""; - for (cp = td->td_inknames; i > 0; cp = strchr(cp,'\0')+1, i--) { + for (cp = td->td_inknames; + i > 0 && cp < td->td_inknames + td->td_inknameslen; + cp = strchr(cp,'\0')+1, i--) { + int max_chars = + td->td_inknameslen - (cp - td->td_inknames); fputs(sep, fd); - _TIFFprintAscii(fd, cp); + _TIFFprintAsciiBounded(fd, cp, max_chars); sep = ", "; } fputs("\n", fd); @@ -386,18 +438,9 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags) } if (TIFFFieldSet(tif,FIELD_YCBCRSUBSAMPLING)) { - /* - * For hacky reasons (see tif_jpeg.c - JPEGFixupTestSubsampling), - * we need to fetch this rather than trust what is in our - * structures. - */ - uint16 subsampling[2]; - - TIFFGetField( tif, TIFFTAG_YCBCRSUBSAMPLING, - subsampling + 0, subsampling + 1 ); fprintf(fd, " YCbCr Subsampling: %u, %u\n", - subsampling[0], subsampling[1] ); - } + td->td_ycbcrsubsampling[0], td->td_ycbcrsubsampling[1] ); + } if (TIFFFieldSet(tif,FIELD_YCBCRPOSITIONING)) { fprintf(fd, " YCbCr Positioning: "); switch (td->td_ycbcrpositioning) { @@ -437,12 +480,20 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags) fprintf(fd, " Min Sample Value: %u\n", td->td_minsamplevalue); if (TIFFFieldSet(tif,FIELD_MAXSAMPLEVALUE)) fprintf(fd, " Max Sample Value: %u\n", td->td_maxsamplevalue); - if (TIFFFieldSet(tif,FIELD_SMINSAMPLEVALUE)) - fprintf(fd, " SMin Sample Value: %g\n", - td->td_sminsamplevalue); - if (TIFFFieldSet(tif,FIELD_SMAXSAMPLEVALUE)) - fprintf(fd, " SMax Sample Value: %g\n", - td->td_smaxsamplevalue); + if (TIFFFieldSet(tif,FIELD_SMINSAMPLEVALUE)) { + int count = (tif->tif_flags & TIFF_PERSAMPLE) ? td->td_samplesperpixel : 1; + fprintf(fd, " SMin Sample Value:"); + for (i = 0; i < count; ++i) + fprintf(fd, " %g", td->td_sminsamplevalue[i]); + fprintf(fd, "\n"); + } + if (TIFFFieldSet(tif,FIELD_SMAXSAMPLEVALUE)) { + int count = (tif->tif_flags & TIFF_PERSAMPLE) ? td->td_samplesperpixel : 1; + fprintf(fd, " SMax Sample Value:"); + for (i = 0; i < count; ++i) + fprintf(fd, " %g", td->td_smaxsamplevalue[i]); + fprintf(fd, "\n"); + } if (TIFFFieldSet(tif,FIELD_PLANARCONFIG)) { fprintf(fd, " Planar Configuration: "); switch (td->td_planarconfig) { @@ -475,6 +526,13 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags) } else fprintf(fd, "(present)\n"); } + if (TIFFFieldSet(tif,FIELD_REFBLACKWHITE)) { + fprintf(fd, " Reference Black/White:\n"); + for (i = 0; i < 3; i++) + fprintf(fd, " %2d: %5g %5g\n", i, + td->td_refblackwhite[2*i+0], + td->td_refblackwhite[2*i+1]); + } if (TIFFFieldSet(tif,FIELD_TRANSFERFUNCTION)) { fprintf(fd, " Transfer Function: "); if (flags & TIFFPRINT_CURVES) { @@ -494,124 +552,136 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags) if (TIFFFieldSet(tif, FIELD_SUBIFD) && (td->td_subifd)) { fprintf(fd, " SubIFD Offsets:"); for (i = 0; i < td->td_nsubifd; i++) - fprintf(fd, " %5lu", (long) td->td_subifd[i]); +#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) + fprintf(fd, " %5I64u", + (unsigned __int64) td->td_subifd[i]); +#else + fprintf(fd, " %5llu", + (unsigned long long) td->td_subifd[i]); +#endif fputc('\n', fd); } - /* - ** Custom tag support. - */ - { - int i; - short count; - - count = (short) TIFFGetTagListCount(tif); - for(i = 0; i < count; i++) { - ttag_t tag = TIFFGetTagListEntry(tif, i); - const TIFFFieldInfo *fip; - uint32 value_count; - int mem_alloc = 0; - void *raw_data; - - fip = TIFFFieldWithTag(tif, tag); - if(fip == NULL) - continue; + /* + ** Custom tag support. + */ + { + int i; + short count; - if(fip->field_passcount) { - if(TIFFGetField(tif, tag, &value_count, &raw_data) != 1) + count = (short) TIFFGetTagListCount(tif); + for(i = 0; i < count; i++) { + uint32 tag = TIFFGetTagListEntry(tif, i); + const TIFFField *fip; + uint32 value_count; + int mem_alloc = 0; + void *raw_data; + + fip = TIFFFieldWithTag(tif, tag); + if(fip == NULL) continue; - } else { - if (fip->field_readcount == TIFF_VARIABLE - || fip->field_readcount == TIFF_VARIABLE2) - value_count = 1; - else if (fip->field_readcount == TIFF_SPP) - value_count = td->td_samplesperpixel; - else - value_count = fip->field_readcount; - if ((fip->field_type == TIFF_ASCII - || fip->field_readcount == TIFF_VARIABLE - || fip->field_readcount == TIFF_VARIABLE2 - || fip->field_readcount == TIFF_SPP - || value_count > 1) - && fip->field_tag != TIFFTAG_PAGENUMBER - && fip->field_tag != TIFFTAG_HALFTONEHINTS - && fip->field_tag != TIFFTAG_YCBCRSUBSAMPLING - && fip->field_tag != TIFFTAG_DOTRANGE) { - if(TIFFGetField(tif, tag, &raw_data) != 1) - continue; - } else if (fip->field_tag != TIFFTAG_PAGENUMBER - && fip->field_tag != TIFFTAG_HALFTONEHINTS - && fip->field_tag != TIFFTAG_YCBCRSUBSAMPLING - && fip->field_tag != TIFFTAG_DOTRANGE) { - raw_data = _TIFFmalloc( - _TIFFDataSize(fip->field_type) - * value_count); - mem_alloc = 1; - if(TIFFGetField(tif, tag, raw_data) != 1) { - _TIFFfree(raw_data); + + if(fip->field_passcount) { + if (fip->field_readcount == TIFF_VARIABLE ) { + if(TIFFGetField(tif, tag, &value_count, &raw_data) != 1) + continue; + } else if (fip->field_readcount == TIFF_VARIABLE2 ) { + uint16 small_value_count; + if(TIFFGetField(tif, tag, &small_value_count, &raw_data) != 1) + continue; + value_count = small_value_count; + } else { + assert (fip->field_readcount == TIFF_VARIABLE + || fip->field_readcount == TIFF_VARIABLE2); continue; - } + } } else { - /* - * XXX: Should be fixed and removed, see the - * notes related to TIFFTAG_PAGENUMBER, - * TIFFTAG_HALFTONEHINTS, - * TIFFTAG_YCBCRSUBSAMPLING and - * TIFFTAG_DOTRANGE tags in tif_dir.c. */ - char *tmp; - raw_data = _TIFFmalloc( - _TIFFDataSize(fip->field_type) - * value_count); - tmp = raw_data; - mem_alloc = 1; - if(TIFFGetField(tif, tag, tmp, - tmp + _TIFFDataSize(fip->field_type)) != 1) { - _TIFFfree(raw_data); - continue; + if (fip->field_readcount == TIFF_VARIABLE + || fip->field_readcount == TIFF_VARIABLE2) + value_count = 1; + else if (fip->field_readcount == TIFF_SPP) + value_count = td->td_samplesperpixel; + else + value_count = fip->field_readcount; + if (fip->field_tag == TIFFTAG_DOTRANGE + && strcmp(fip->field_name,"DotRange") == 0) { + /* TODO: This is an evil exception and should not have been + handled this way ... likely best if we move it into + the directory structure with an explicit field in + libtiff 4.1 and assign it a FIELD_ value */ + static uint16 dotrange[2]; + raw_data = dotrange; + TIFFGetField(tif, tag, dotrange+0, dotrange+1); + } else if (fip->field_type == TIFF_ASCII + || fip->field_readcount == TIFF_VARIABLE + || fip->field_readcount == TIFF_VARIABLE2 + || fip->field_readcount == TIFF_SPP + || value_count > 1) { + if(TIFFGetField(tif, tag, &raw_data) != 1) + continue; + } else { + raw_data = _TIFFmalloc( + _TIFFDataSize(fip->field_type) + * value_count); + mem_alloc = 1; + if(TIFFGetField(tif, tag, raw_data) != 1) { + _TIFFfree(raw_data); + continue; + } } } - } - /* - * Catch the tags which needs to be specially handled and - * pretty print them. If tag not handled in - * _TIFFPrettyPrintField() fall down and print it as any other - * tag. - */ - if (_TIFFPrettyPrintField(tif, fd, tag, value_count, raw_data)) { + /* + * Catch the tags which needs to be specially handled + * and pretty print them. If tag not handled in + * _TIFFPrettyPrintField() fall down and print it as + * any other tag. + */ + if (!_TIFFPrettyPrintField(tif, fip, fd, tag, value_count, raw_data)) + _TIFFPrintField(fd, fip, value_count, raw_data); + if(mem_alloc) _TIFFfree(raw_data); - continue; } - else - _TIFFPrintField(fd, fip, value_count, raw_data); - - if(mem_alloc) - _TIFFfree(raw_data); - } - } + } if (tif->tif_tagmethods.printdir) (*tif->tif_tagmethods.printdir)(tif, fd, flags); + + _TIFFFillStriles( tif ); + if ((flags & TIFFPRINT_STRIPS) && TIFFFieldSet(tif,FIELD_STRIPOFFSETS)) { - tstrip_t s; + uint32 s; fprintf(fd, " %lu %s:\n", (long) td->td_nstrips, isTiled(tif) ? "Tiles" : "Strips"); for (s = 0; s < td->td_nstrips; s++) - fprintf(fd, " %3lu: [%8lu, %8lu]\n", +#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) + fprintf(fd, " %3lu: [%8I64u, %8I64u]\n", + (unsigned long) s, + (unsigned __int64) td->td_stripoffset[s], + (unsigned __int64) td->td_stripbytecount[s]); +#else + fprintf(fd, " %3lu: [%8llu, %8llu]\n", (unsigned long) s, - (unsigned long) td->td_stripoffset[s], - (unsigned long) td->td_stripbytecount[s]); + (unsigned long long) td->td_stripoffset[s], + (unsigned long long) td->td_stripbytecount[s]); +#endif } } void _TIFFprintAscii(FILE* fd, const char* cp) { - for (; *cp != '\0'; cp++) { + _TIFFprintAsciiBounded( fd, cp, strlen(cp)); +} + +static void +_TIFFprintAsciiBounded(FILE* fd, const char* cp, int max_chars) +{ + for (; max_chars > 0 && *cp != '\0'; cp++, max_chars--) { const char* tp; if (isprint((int)*cp)) { @@ -637,3 +707,10 @@ _TIFFprintAsciiTag(FILE* fd, const char* name, const char* value) } /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_read.c b/src/3rdparty/libtiff/libtiff/tif_read.c index 92e4746..fe36e68 100644 --- a/src/3rdparty/libtiff/libtiff/tif_read.c +++ b/src/3rdparty/libtiff/libtiff/tif_read.c @@ -1,4 +1,4 @@ -/* $Id: tif_read.c,v 1.16 2007/02/22 11:33:44 dron Exp $ */ +/* $Id: tif_read.c,v 1.41 2012-07-06 19:22:58 bfriesen Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler @@ -31,29 +31,161 @@ #include "tiffiop.h" #include <stdio.h> - int TIFFFillStrip(TIFF*, tstrip_t); - int TIFFFillTile(TIFF*, ttile_t); -static int TIFFStartStrip(TIFF*, tstrip_t); -static int TIFFStartTile(TIFF*, ttile_t); -static int TIFFCheckRead(TIFF*, int); +int TIFFFillStrip(TIFF* tif, uint32 strip); +int TIFFFillTile(TIFF* tif, uint32 tile); +static int TIFFStartStrip(TIFF* tif, uint32 strip); +static int TIFFStartTile(TIFF* tif, uint32 tile); +static int TIFFCheckRead(TIFF*, int); +static tmsize_t +TIFFReadRawStrip1(TIFF* tif, uint32 strip, void* buf, tmsize_t size,const char* module); -#define NOSTRIP ((tstrip_t) -1) /* undefined state */ -#define NOTILE ((ttile_t) -1) /* undefined state */ +#define NOSTRIP ((uint32)(-1)) /* undefined state */ +#define NOTILE ((uint32)(-1)) /* undefined state */ + +static int +TIFFFillStripPartial( TIFF *tif, int strip, tmsize_t read_ahead, int restart ) +{ + static const char module[] = "TIFFFillStripPartial"; + register TIFFDirectory *td = &tif->tif_dir; + uint64 unused_data; + uint64 read_offset; + tmsize_t cc, to_read; + /* tmsize_t bytecountm; */ + + if (!_TIFFFillStriles( tif ) || !tif->tif_dir.td_stripbytecount) + return 0; + + /* + * Expand raw data buffer, if needed, to hold data + * strip coming from file (perhaps should set upper + * bound on the size of a buffer we'll use?). + */ + + /* bytecountm=(tmsize_t) td->td_stripbytecount[strip]; */ + if (read_ahead*2 > tif->tif_rawdatasize) { + assert( restart ); + + tif->tif_curstrip = NOSTRIP; + if ((tif->tif_flags & TIFF_MYBUFFER) == 0) { + TIFFErrorExt(tif->tif_clientdata, module, + "Data buffer too small to hold part of strip %lu", + (unsigned long) strip); + return (0); + } + if (!TIFFReadBufferSetup(tif, 0, read_ahead*2)) + return (0); + } + + if( restart ) + { + tif->tif_rawdataloaded = 0; + tif->tif_rawdataoff = 0; + } + + /* + ** If we are reading more data, move any unused data to the + ** start of the buffer. + */ + if( tif->tif_rawdataloaded > 0 ) + unused_data = tif->tif_rawdataloaded - (tif->tif_rawcp - tif->tif_rawdata); + else + unused_data = 0; + + if( unused_data > 0 ) + { + assert((tif->tif_flags&TIFF_BUFFERMMAP)==0); + memmove( tif->tif_rawdata, tif->tif_rawcp, unused_data ); + } + + /* + ** Seek to the point in the file where more data should be read. + */ + read_offset = td->td_stripoffset[strip] + + tif->tif_rawdataoff + tif->tif_rawdataloaded; + + if (!SeekOK(tif, read_offset)) { + TIFFErrorExt(tif->tif_clientdata, module, + "Seek error at scanline %lu, strip %lu", + (unsigned long) tif->tif_row, (unsigned long) strip); + return 0; + } + + /* + ** How much do we want to read? + */ + to_read = tif->tif_rawdatasize - unused_data; + if( (uint64) to_read > td->td_stripbytecount[strip] + - tif->tif_rawdataoff - tif->tif_rawdataloaded ) + { + to_read = td->td_stripbytecount[strip] + - tif->tif_rawdataoff - tif->tif_rawdataloaded; + } + + assert((tif->tif_flags&TIFF_BUFFERMMAP)==0); + cc = TIFFReadFile(tif, tif->tif_rawdata + unused_data, to_read); + + if (cc != to_read) { +#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) + TIFFErrorExt(tif->tif_clientdata, module, + "Read error at scanline %lu; got %I64u bytes, expected %I64u", + (unsigned long) tif->tif_row, + (unsigned __int64) cc, + (unsigned __int64) to_read); +#else + TIFFErrorExt(tif->tif_clientdata, module, + "Read error at scanline %lu; got %llu bytes, expected %llu", + (unsigned long) tif->tif_row, + (unsigned long long) cc, + (unsigned long long) to_read); +#endif + return 0; + } + + tif->tif_rawdataoff = tif->tif_rawdataoff + tif->tif_rawdataloaded - unused_data ; + tif->tif_rawdataloaded = unused_data + to_read; + + tif->tif_rawcp = tif->tif_rawdata; + + if (!isFillOrder(tif, td->td_fillorder) && + (tif->tif_flags & TIFF_NOBITREV) == 0) { + assert((tif->tif_flags&TIFF_BUFFERMMAP)==0); + TIFFReverseBits(tif->tif_rawdata + unused_data, to_read ); + } + + /* + ** When starting a strip from the beginning we need to + ** restart the decoder. + */ + if( restart ) + return TIFFStartStrip(tif, strip); + else + return 1; +} /* * Seek to a random row+sample in a file. + * + * Only used by TIFFReadScanline, and is only used on + * strip organized files. We do some tricky stuff to try + * and avoid reading the whole compressed raw data for big + * strips. */ static int -TIFFSeek(TIFF* tif, uint32 row, tsample_t sample) +TIFFSeek(TIFF* tif, uint32 row, uint16 sample ) { register TIFFDirectory *td = &tif->tif_dir; - tstrip_t strip; + uint32 strip; + int whole_strip; + tmsize_t read_ahead = 0; + /* + ** Establish what strip we are working from. + */ if (row >= td->td_imagelength) { /* out of range */ TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "%lu: Row out of range, max %lu", - (unsigned long) row, - (unsigned long) td->td_imagelength); + "%lu: Row out of range, max %lu", + (unsigned long) row, + (unsigned long) td->td_imagelength); return (0); } if (td->td_planarconfig == PLANARCONFIG_SEPARATE) { @@ -63,13 +195,60 @@ TIFFSeek(TIFF* tif, uint32 row, tsample_t sample) (unsigned long) sample, (unsigned long) td->td_samplesperpixel); return (0); } - strip = sample*td->td_stripsperimage + row/td->td_rowsperstrip; + strip = (uint32)sample*td->td_stripsperimage + row/td->td_rowsperstrip; } else strip = row / td->td_rowsperstrip; + + /* + * Do we want to treat this strip as one whole chunk or + * read it a few lines at a time? + */ +#if defined(CHUNKY_STRIP_READ_SUPPORT) + if (!_TIFFFillStriles( tif ) || !tif->tif_dir.td_stripbytecount) + return 0; + whole_strip = tif->tif_dir.td_stripbytecount[strip] < 10 + || isMapped(tif); +#else + whole_strip = 1; +#endif + + if( !whole_strip ) + { + read_ahead = tif->tif_scanlinesize * 16 + 5000; + } + + /* + * If we haven't loaded this strip, do so now, possibly + * only reading the first part. + */ if (strip != tif->tif_curstrip) { /* different strip, refill */ - if (!TIFFFillStrip(tif, strip)) - return (0); - } else if (row < tif->tif_row) { + + if( whole_strip ) + { + if (!TIFFFillStrip(tif, strip)) + return (0); + } + else + { + if( !TIFFFillStripPartial(tif,strip,read_ahead,1) ) + return 0; + } + } + + /* + ** If we already have some data loaded, do we need to read some more? + */ + else if( !whole_strip ) + { + if( ((tif->tif_rawdata + tif->tif_rawdataloaded) - tif->tif_rawcp) < read_ahead + && (uint64) tif->tif_rawdataoff+tif->tif_rawdataloaded < td->td_stripbytecount[strip] ) + { + if( !TIFFFillStripPartial(tif,strip,read_ahead,0) ) + return 0; + } + } + + if (row < tif->tif_row) { /* * Moving backwards within the same strip: backup * to the start and then decode forward (below). @@ -78,22 +257,36 @@ TIFFSeek(TIFF* tif, uint32 row, tsample_t sample) * strip, it's better to just read and decode the entire * strip, and then access the decoded data in a random fashion. */ - if (!TIFFStartStrip(tif, strip)) - return (0); + + if( tif->tif_rawdataoff != 0 ) + { + if( !TIFFFillStripPartial(tif,strip,read_ahead,1) ) + return 0; + } + else + { + if (!TIFFStartStrip(tif, strip)) + return (0); + } } + if (row != tif->tif_row) { /* * Seek forward to the desired row. */ + + /* TODO: Will this really work with partial buffers? */ + if (!(*tif->tif_seek)(tif, row - tif->tif_row)) return (0); tif->tif_row = row; } + return (1); } int -TIFFReadScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample) +TIFFReadScanline(TIFF* tif, void* buf, uint32 row, uint16 sample) { int e; @@ -104,14 +297,14 @@ TIFFReadScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample) * Decompress desired row into user buffer. */ e = (*tif->tif_decoderow) - (tif, (tidata_t) buf, tif->tif_scanlinesize, sample); + (tif, (uint8*) buf, tif->tif_scanlinesize, sample); /* we are now poised at the beginning of the next row */ tif->tif_row = row + 1; if (e) - (*tif->tif_postdecode)(tif, (tidata_t) buf, - tif->tif_scanlinesize); + (*tif->tif_postdecode)(tif, (uint8*) buf, + tif->tif_scanlinesize); } return (e > 0 ? 1 : -1); } @@ -120,93 +313,120 @@ TIFFReadScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample) * Read a strip of data and decompress the specified * amount into the user-supplied buffer. */ -tsize_t -TIFFReadEncodedStrip(TIFF* tif, tstrip_t strip, tdata_t buf, tsize_t size) +tmsize_t +TIFFReadEncodedStrip(TIFF* tif, uint32 strip, void* buf, tmsize_t size) { + static const char module[] = "TIFFReadEncodedStrip"; TIFFDirectory *td = &tif->tif_dir; - uint32 nrows; - tsize_t stripsize; - tstrip_t sep_strip, strips_per_sep; - - if (!TIFFCheckRead(tif, 0)) - return (-1); - if (strip >= td->td_nstrips) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "%ld: Strip out of range, max %ld", - (long) strip, (long) td->td_nstrips); - return (-1); + uint32 rowsperstrip; + uint32 stripsperplane; + uint32 stripinplane; + uint16 plane; + uint32 rows; + tmsize_t stripsize; + if (!TIFFCheckRead(tif,0)) + return((tmsize_t)(-1)); + if (strip>=td->td_nstrips) + { + TIFFErrorExt(tif->tif_clientdata,module, + "%lu: Strip out of range, max %lu",(unsigned long)strip, + (unsigned long)td->td_nstrips); + return((tmsize_t)(-1)); } /* * Calculate the strip size according to the number of * rows in the strip (check for truncated last strip on any * of the separations). */ - if( td->td_rowsperstrip >= td->td_imagelength ) - strips_per_sep = 1; - else - strips_per_sep = (td->td_imagelength+td->td_rowsperstrip-1) - / td->td_rowsperstrip; - - sep_strip = strip % strips_per_sep; - - if (sep_strip != strips_per_sep-1 || - (nrows = td->td_imagelength % td->td_rowsperstrip) == 0) - nrows = td->td_rowsperstrip; - - stripsize = TIFFVStripSize(tif, nrows); - if (size == (tsize_t) -1) - size = stripsize; - else if (size > stripsize) - size = stripsize; - if (TIFFFillStrip(tif, strip) - && (*tif->tif_decodestrip)(tif, (tidata_t) buf, size, - (tsample_t)(strip / td->td_stripsperimage)) > 0 ) { - (*tif->tif_postdecode)(tif, (tidata_t) buf, size); - return (size); - } else - return ((tsize_t) -1); + rowsperstrip=td->td_rowsperstrip; + if (rowsperstrip>td->td_imagelength) + rowsperstrip=td->td_imagelength; + stripsperplane=((td->td_imagelength+rowsperstrip-1)/rowsperstrip); + stripinplane=(strip%stripsperplane); + plane=(strip/stripsperplane); + rows=td->td_imagelength-stripinplane*rowsperstrip; + if (rows>rowsperstrip) + rows=rowsperstrip; + stripsize=TIFFVStripSize(tif,rows); + if (stripsize==0) + return((tmsize_t)(-1)); + if ((size!=(tmsize_t)(-1))&&(size<stripsize)) + stripsize=size; + if (!TIFFFillStrip(tif,strip)) + return((tmsize_t)(-1)); + if ((*tif->tif_decodestrip)(tif,buf,stripsize,plane)<=0) + return((tmsize_t)(-1)); + (*tif->tif_postdecode)(tif,buf,stripsize); + return(stripsize); } -static tsize_t -TIFFReadRawStrip1(TIFF* tif, - tstrip_t strip, tdata_t buf, tsize_t size, const char* module) +static tmsize_t +TIFFReadRawStrip1(TIFF* tif, uint32 strip, void* buf, tmsize_t size, + const char* module) { TIFFDirectory *td = &tif->tif_dir; + if (!_TIFFFillStriles( tif )) + return ((tmsize_t)(-1)); + assert((tif->tif_flags&TIFF_NOREADRAW)==0); if (!isMapped(tif)) { - tsize_t cc; + tmsize_t cc; if (!SeekOK(tif, td->td_stripoffset[strip])) { TIFFErrorExt(tif->tif_clientdata, module, - "%s: Seek error at scanline %lu, strip %lu", - tif->tif_name, + "Seek error at scanline %lu, strip %lu", (unsigned long) tif->tif_row, (unsigned long) strip); - return (-1); + return ((tmsize_t)(-1)); } cc = TIFFReadFile(tif, buf, size); if (cc != size) { +#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) TIFFErrorExt(tif->tif_clientdata, module, - "%s: Read error at scanline %lu; got %lu bytes, expected %lu", - tif->tif_name, - (unsigned long) tif->tif_row, - (unsigned long) cc, - (unsigned long) size); - return (-1); + "Read error at scanline %lu; got %I64u bytes, expected %I64u", + (unsigned long) tif->tif_row, + (unsigned __int64) cc, + (unsigned __int64) size); +#else + TIFFErrorExt(tif->tif_clientdata, module, + "Read error at scanline %lu; got %llu bytes, expected %llu", + (unsigned long) tif->tif_row, + (unsigned long long) cc, + (unsigned long long) size); +#endif + return ((tmsize_t)(-1)); } } else { - if (td->td_stripoffset[strip] + size > tif->tif_size) { + tmsize_t ma,mb; + tmsize_t n; + ma=(tmsize_t)td->td_stripoffset[strip]; + mb=ma+size; + if (((uint64)ma!=td->td_stripoffset[strip])||(ma>tif->tif_size)) + n=0; + else if ((mb<ma)||(mb<size)||(mb>tif->tif_size)) + n=tif->tif_size-ma; + else + n=size; + if (n!=size) { +#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) TIFFErrorExt(tif->tif_clientdata, module, - "%s: Read error at scanline %lu, strip %lu; got %lu bytes, expected %lu", - tif->tif_name, - (unsigned long) tif->tif_row, - (unsigned long) strip, - (unsigned long) tif->tif_size - td->td_stripoffset[strip], - (unsigned long) size); - return (-1); + "Read error at scanline %lu, strip %lu; got %I64u bytes, expected %I64u", + (unsigned long) tif->tif_row, + (unsigned long) strip, + (unsigned __int64) n, + (unsigned __int64) size); +#else + TIFFErrorExt(tif->tif_clientdata, module, + "Read error at scanline %lu, strip %lu; got %llu bytes, expected %llu", + (unsigned long) tif->tif_row, + (unsigned long) strip, + (unsigned long long) n, + (unsigned long long) size); +#endif + return ((tmsize_t)(-1)); } - _TIFFmemcpy(buf, tif->tif_base + td->td_stripoffset[strip], - size); + _TIFFmemcpy(buf, tif->tif_base + ma, + size); } return (size); } @@ -214,44 +434,52 @@ TIFFReadRawStrip1(TIFF* tif, /* * Read a strip of data from the file. */ -tsize_t -TIFFReadRawStrip(TIFF* tif, tstrip_t strip, tdata_t buf, tsize_t size) +tmsize_t +TIFFReadRawStrip(TIFF* tif, uint32 strip, void* buf, tmsize_t size) { static const char module[] = "TIFFReadRawStrip"; TIFFDirectory *td = &tif->tif_dir; - /* - * FIXME: butecount should have tsize_t type, but for now libtiff - * defines tsize_t as a signed 32-bit integer and we are losing - * ability to read arrays larger than 2^31 bytes. So we are using - * uint32 instead of tsize_t here. - */ - uint32 bytecount; + uint64 bytecount; + tmsize_t bytecountm; if (!TIFFCheckRead(tif, 0)) - return ((tsize_t) -1); + return ((tmsize_t)(-1)); if (strip >= td->td_nstrips) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "%lu: Strip out of range, max %lu", - (unsigned long) strip, - (unsigned long) td->td_nstrips); - return ((tsize_t) -1); + TIFFErrorExt(tif->tif_clientdata, module, + "%lu: Strip out of range, max %lu", + (unsigned long) strip, + (unsigned long) td->td_nstrips); + return ((tmsize_t)(-1)); } if (tif->tif_flags&TIFF_NOREADRAW) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Compression scheme does not support access to raw uncompressed data"); - return ((tsize_t) -1); + TIFFErrorExt(tif->tif_clientdata, module, + "Compression scheme does not support access to raw uncompressed data"); + return ((tmsize_t)(-1)); } bytecount = td->td_stripbytecount[strip]; if (bytecount <= 0) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "%lu: Invalid strip byte count, strip %lu", - (unsigned long) bytecount, (unsigned long) strip); - return ((tsize_t) -1); +#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) + TIFFErrorExt(tif->tif_clientdata, module, + "%I64u: Invalid strip byte count, strip %lu", + (unsigned __int64) bytecount, + (unsigned long) strip); +#else + TIFFErrorExt(tif->tif_clientdata, module, + "%llu: Invalid strip byte count, strip %lu", + (unsigned long long) bytecount, + (unsigned long) strip); +#endif + return ((tmsize_t)(-1)); + } + bytecountm = (tmsize_t)bytecount; + if ((uint64)bytecountm!=bytecount) { + TIFFErrorExt(tif->tif_clientdata, module, "Integer overflow"); + return ((tmsize_t)(-1)); } - if (size != (tsize_t)-1 && (uint32)size < bytecount) - bytecount = size; - return (TIFFReadRawStrip1(tif, strip, buf, bytecount, module)); + if (size != (tmsize_t)(-1) && size < bytecountm) + bytecountm = size; + return (TIFFReadRawStrip1(tif, strip, buf, bytecountm, module)); } /* @@ -259,25 +487,29 @@ TIFFReadRawStrip(TIFF* tif, tstrip_t strip, tdata_t buf, tsize_t size) * expanded, as necessary, to hold the strip's data. */ int -TIFFFillStrip(TIFF* tif, tstrip_t strip) +TIFFFillStrip(TIFF* tif, uint32 strip) { static const char module[] = "TIFFFillStrip"; TIFFDirectory *td = &tif->tif_dir; + if (!_TIFFFillStriles( tif ) || !tif->tif_dir.td_stripbytecount) + return 0; + if ((tif->tif_flags&TIFF_NOREADRAW)==0) { - /* - * FIXME: butecount should have tsize_t type, but for now - * libtiff defines tsize_t as a signed 32-bit integer and we - * are losing ability to read arrays larger than 2^31 bytes. - * So we are using uint32 instead of tsize_t here. - */ - uint32 bytecount = td->td_stripbytecount[strip]; + uint64 bytecount = td->td_stripbytecount[strip]; if (bytecount <= 0) { +#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) + TIFFErrorExt(tif->tif_clientdata, module, + "Invalid strip byte count %I64u, strip %lu", + (unsigned __int64) bytecount, + (unsigned long) strip); +#else TIFFErrorExt(tif->tif_clientdata, module, - "%s: Invalid strip byte count %lu, strip %lu", - tif->tif_name, (unsigned long) bytecount, - (unsigned long) strip); + "Invalid strip byte count %llu, strip %lu", + (unsigned long long) bytecount, + (unsigned long) strip); +#endif return (0); } if (isMapped(tif) && @@ -294,8 +526,11 @@ TIFFFillStrip(TIFF* tif, tstrip_t strip) * buffer (if they try to, the application will get a * fault since the file is mapped read-only). */ - if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) + if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) { _TIFFfree(tif->tif_rawdata); + tif->tif_rawdata = NULL; + tif->tif_rawdatasize = 0; + } tif->tif_flags &= ~TIFF_MYBUFFER; /* * We must check for overflow, potentially causing @@ -306,53 +541,85 @@ TIFFFillStrip(TIFF* tif, tstrip_t strip) * comparison (which can overflow) we do the following * two comparisons: */ - if (bytecount > tif->tif_size || - td->td_stripoffset[strip] > tif->tif_size - bytecount) { + if (bytecount > (uint64)tif->tif_size || + td->td_stripoffset[strip] > (uint64)tif->tif_size - bytecount) { /* * This error message might seem strange, but * it's what would happen if a read were done * instead. */ +#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) TIFFErrorExt(tif->tif_clientdata, module, - "%s: Read error on strip %lu; " - "got %lu bytes, expected %lu", - tif->tif_name, (unsigned long) strip, - (unsigned long) tif->tif_size - td->td_stripoffset[strip], - (unsigned long) bytecount); + "Read error on strip %lu; " + "got %I64u bytes, expected %I64u", + (unsigned long) strip, + (unsigned __int64) tif->tif_size - td->td_stripoffset[strip], + (unsigned __int64) bytecount); +#else + TIFFErrorExt(tif->tif_clientdata, module, + + "Read error on strip %lu; " + "got %llu bytes, expected %llu", + (unsigned long) strip, + (unsigned long long) tif->tif_size - td->td_stripoffset[strip], + (unsigned long long) bytecount); +#endif tif->tif_curstrip = NOSTRIP; return (0); } - tif->tif_rawdatasize = bytecount; - tif->tif_rawdata = tif->tif_base + td->td_stripoffset[strip]; + tif->tif_rawdatasize = (tmsize_t)bytecount; + tif->tif_rawdata = tif->tif_base + (tmsize_t)td->td_stripoffset[strip]; + tif->tif_rawdataoff = 0; + tif->tif_rawdataloaded = (tmsize_t) bytecount; + + /* + * When we have tif_rawdata reference directly into the memory mapped file + * we need to be pretty careful about how we use the rawdata. It is not + * a general purpose working buffer as it normally otherwise is. So we + * keep track of this fact to avoid using it improperly. + */ + tif->tif_flags |= TIFF_BUFFERMMAP; } else { /* * Expand raw data buffer, if needed, to hold data * strip coming from file (perhaps should set upper * bound on the size of a buffer we'll use?). */ - if (bytecount > (uint32)tif->tif_rawdatasize) { + tmsize_t bytecountm; + bytecountm=(tmsize_t)bytecount; + if ((uint64)bytecountm!=bytecount) + { + TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow"); + return(0); + } + if (bytecountm > tif->tif_rawdatasize) { tif->tif_curstrip = NOSTRIP; if ((tif->tif_flags & TIFF_MYBUFFER) == 0) { - TIFFErrorExt(tif->tif_clientdata, - module, - "%s: Data buffer too small to hold strip %lu", - tif->tif_name, - (unsigned long) strip); + TIFFErrorExt(tif->tif_clientdata, module, + "Data buffer too small to hold strip %lu", + (unsigned long) strip); return (0); } - if (!TIFFReadBufferSetup(tif, 0, - TIFFroundup(bytecount, 1024))) + if (!TIFFReadBufferSetup(tif, 0, bytecountm)) + return (0); + } + if (tif->tif_flags&TIFF_BUFFERMMAP) { + tif->tif_curstrip = NOSTRIP; + if (!TIFFReadBufferSetup(tif, 0, bytecountm)) return (0); } - if ((uint32)TIFFReadRawStrip1(tif, strip, - (unsigned char *)tif->tif_rawdata, - bytecount, module) != bytecount) + if (TIFFReadRawStrip1(tif, strip, tif->tif_rawdata, + bytecountm, module) != bytecountm) return (0); + + tif->tif_rawdataoff = 0; + tif->tif_rawdataloaded = bytecountm; + if (!isFillOrder(tif, td->td_fillorder) && (tif->tif_flags & TIFF_NOBITREV) == 0) - TIFFReverseBits(tif->tif_rawdata, bytecount); - } + TIFFReverseBits(tif->tif_rawdata, bytecountm); + } } return (TIFFStartStrip(tif, strip)); } @@ -366,89 +633,117 @@ TIFFFillStrip(TIFF* tif, tstrip_t strip) * Read and decompress a tile of data. The * tile is selected by the (x,y,z,s) coordinates. */ -tsize_t -TIFFReadTile(TIFF* tif, - tdata_t buf, uint32 x, uint32 y, uint32 z, tsample_t s) +tmsize_t +TIFFReadTile(TIFF* tif, void* buf, uint32 x, uint32 y, uint32 z, uint16 s) { if (!TIFFCheckRead(tif, 1) || !TIFFCheckTile(tif, x, y, z, s)) - return (-1); + return ((tmsize_t)(-1)); return (TIFFReadEncodedTile(tif, - TIFFComputeTile(tif, x, y, z, s), buf, (tsize_t) -1)); + TIFFComputeTile(tif, x, y, z, s), buf, (tmsize_t)(-1))); } /* * Read a tile of data and decompress the specified * amount into the user-supplied buffer. */ -tsize_t -TIFFReadEncodedTile(TIFF* tif, ttile_t tile, tdata_t buf, tsize_t size) +tmsize_t +TIFFReadEncodedTile(TIFF* tif, uint32 tile, void* buf, tmsize_t size) { + static const char module[] = "TIFFReadEncodedTile"; TIFFDirectory *td = &tif->tif_dir; - tsize_t tilesize = tif->tif_tilesize; + tmsize_t tilesize = tif->tif_tilesize; if (!TIFFCheckRead(tif, 1)) - return (-1); + return ((tmsize_t)(-1)); if (tile >= td->td_nstrips) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "%ld: Tile out of range, max %ld", - (long) tile, (unsigned long) td->td_nstrips); - return (-1); + TIFFErrorExt(tif->tif_clientdata, module, + "%lu: Tile out of range, max %lu", + (unsigned long) tile, (unsigned long) td->td_nstrips); + return ((tmsize_t)(-1)); } - if (size == (tsize_t) -1) + if (size == (tmsize_t)(-1)) size = tilesize; else if (size > tilesize) size = tilesize; if (TIFFFillTile(tif, tile) && (*tif->tif_decodetile)(tif, - (tidata_t) buf, size, (tsample_t)(tile/td->td_stripsperimage))) { - (*tif->tif_postdecode)(tif, (tidata_t) buf, size); + (uint8*) buf, size, (uint16)(tile/td->td_stripsperimage))) { + (*tif->tif_postdecode)(tif, (uint8*) buf, size); return (size); } else - return (-1); + return ((tmsize_t)(-1)); } -static tsize_t -TIFFReadRawTile1(TIFF* tif, - ttile_t tile, tdata_t buf, tsize_t size, const char* module) +static tmsize_t +TIFFReadRawTile1(TIFF* tif, uint32 tile, void* buf, tmsize_t size, const char* module) { TIFFDirectory *td = &tif->tif_dir; + if (!_TIFFFillStriles( tif )) + return ((tmsize_t)(-1)); + assert((tif->tif_flags&TIFF_NOREADRAW)==0); if (!isMapped(tif)) { - tsize_t cc; + tmsize_t cc; if (!SeekOK(tif, td->td_stripoffset[tile])) { TIFFErrorExt(tif->tif_clientdata, module, - "%s: Seek error at row %ld, col %ld, tile %ld", - tif->tif_name, - (long) tif->tif_row, - (long) tif->tif_col, - (long) tile); - return ((tsize_t) -1); + "Seek error at row %lu, col %lu, tile %lu", + (unsigned long) tif->tif_row, + (unsigned long) tif->tif_col, + (unsigned long) tile); + return ((tmsize_t)(-1)); } cc = TIFFReadFile(tif, buf, size); if (cc != size) { +#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) + TIFFErrorExt(tif->tif_clientdata, module, + "Read error at row %lu, col %lu; got %I64u bytes, expected %I64u", + (unsigned long) tif->tif_row, + (unsigned long) tif->tif_col, + (unsigned __int64) cc, + (unsigned __int64) size); +#else TIFFErrorExt(tif->tif_clientdata, module, - "%s: Read error at row %ld, col %ld; got %lu bytes, expected %lu", - tif->tif_name, - (long) tif->tif_row, - (long) tif->tif_col, - (unsigned long) cc, - (unsigned long) size); - return ((tsize_t) -1); + "Read error at row %lu, col %lu; got %llu bytes, expected %llu", + (unsigned long) tif->tif_row, + (unsigned long) tif->tif_col, + (unsigned long long) cc, + (unsigned long long) size); +#endif + return ((tmsize_t)(-1)); } } else { - if (td->td_stripoffset[tile] + size > tif->tif_size) { + tmsize_t ma,mb; + tmsize_t n; + ma=(tmsize_t)td->td_stripoffset[tile]; + mb=ma+size; + if (((uint64)ma!=td->td_stripoffset[tile])||(ma>tif->tif_size)) + n=0; + else if ((mb<ma)||(mb<size)||(mb>tif->tif_size)) + n=tif->tif_size-ma; + else + n=size; + if (n!=size) { +#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) TIFFErrorExt(tif->tif_clientdata, module, - "%s: Read error at row %ld, col %ld, tile %ld; got %lu bytes, expected %lu", - tif->tif_name, - (long) tif->tif_row, - (long) tif->tif_col, - (long) tile, - (unsigned long) tif->tif_size - td->td_stripoffset[tile], - (unsigned long) size); - return ((tsize_t) -1); +"Read error at row %lu, col %lu, tile %lu; got %I64u bytes, expected %I64u", + (unsigned long) tif->tif_row, + (unsigned long) tif->tif_col, + (unsigned long) tile, + (unsigned __int64) n, + (unsigned __int64) size); +#else + TIFFErrorExt(tif->tif_clientdata, module, +"Read error at row %lu, col %lu, tile %lu; got %llu bytes, expected %llu", + (unsigned long) tif->tif_row, + (unsigned long) tif->tif_col, + (unsigned long) tile, + (unsigned long long) n, + (unsigned long long) size); +#endif + return ((tmsize_t)(-1)); } - _TIFFmemcpy(buf, tif->tif_base + td->td_stripoffset[tile], size); + _TIFFmemcpy(buf, tif->tif_base + ma, size); } return (size); } @@ -456,37 +751,38 @@ TIFFReadRawTile1(TIFF* tif, /* * Read a tile of data from the file. */ -tsize_t -TIFFReadRawTile(TIFF* tif, ttile_t tile, tdata_t buf, tsize_t size) +tmsize_t +TIFFReadRawTile(TIFF* tif, uint32 tile, void* buf, tmsize_t size) { static const char module[] = "TIFFReadRawTile"; TIFFDirectory *td = &tif->tif_dir; - /* - * FIXME: butecount should have tsize_t type, but for now libtiff - * defines tsize_t as a signed 32-bit integer and we are losing - * ability to read arrays larger than 2^31 bytes. So we are using - * uint32 instead of tsize_t here. - */ - uint32 bytecount; + uint64 bytecount64; + tmsize_t bytecountm; if (!TIFFCheckRead(tif, 1)) - return ((tsize_t) -1); + return ((tmsize_t)(-1)); if (tile >= td->td_nstrips) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "%lu: Tile out of range, max %lu", + TIFFErrorExt(tif->tif_clientdata, module, + "%lu: Tile out of range, max %lu", (unsigned long) tile, (unsigned long) td->td_nstrips); - return ((tsize_t) -1); + return ((tmsize_t)(-1)); } if (tif->tif_flags&TIFF_NOREADRAW) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Compression scheme does not support access to raw uncompressed data"); - return ((tsize_t) -1); + TIFFErrorExt(tif->tif_clientdata, module, + "Compression scheme does not support access to raw uncompressed data"); + return ((tmsize_t)(-1)); } - bytecount = td->td_stripbytecount[tile]; - if (size != (tsize_t) -1 && (uint32)size < bytecount) - bytecount = size; - return (TIFFReadRawTile1(tif, tile, buf, bytecount, module)); + bytecount64 = td->td_stripbytecount[tile]; + if (size != (tmsize_t)(-1) && (uint64)size < bytecount64) + bytecount64 = (uint64)size; + bytecountm = (tmsize_t)bytecount64; + if ((uint64)bytecountm!=bytecount64) + { + TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow"); + return ((tmsize_t)(-1)); + } + return (TIFFReadRawTile1(tif, tile, buf, bytecountm, module)); } /* @@ -494,24 +790,29 @@ TIFFReadRawTile(TIFF* tif, ttile_t tile, tdata_t buf, tsize_t size) * expanded, as necessary, to hold the tile's data. */ int -TIFFFillTile(TIFF* tif, ttile_t tile) +TIFFFillTile(TIFF* tif, uint32 tile) { static const char module[] = "TIFFFillTile"; TIFFDirectory *td = &tif->tif_dir; + if (!_TIFFFillStriles( tif ) || !tif->tif_dir.td_stripbytecount) + return 0; + if ((tif->tif_flags&TIFF_NOREADRAW)==0) { - /* - * FIXME: butecount should have tsize_t type, but for now - * libtiff defines tsize_t as a signed 32-bit integer and we - * are losing ability to read arrays larger than 2^31 bytes. - * So we are using uint32 instead of tsize_t here. - */ - uint32 bytecount = td->td_stripbytecount[tile]; + uint64 bytecount = td->td_stripbytecount[tile]; if (bytecount <= 0) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "%lu: Invalid tile byte count, tile %lu", - (unsigned long) bytecount, (unsigned long) tile); +#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) + TIFFErrorExt(tif->tif_clientdata, module, + "%I64u: Invalid tile byte count, tile %lu", + (unsigned __int64) bytecount, + (unsigned long) tile); +#else + TIFFErrorExt(tif->tif_clientdata, module, + "%llu: Invalid tile byte count, tile %lu", + (unsigned long long) bytecount, + (unsigned long) tile); +#endif return (0); } if (isMapped(tif) && @@ -528,8 +829,11 @@ TIFFFillTile(TIFF* tif, ttile_t tile) * buffer (if they try to, the application will get a * fault since the file is mapped read-only). */ - if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) + if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) { _TIFFfree(tif->tif_rawdata); + tif->tif_rawdata = NULL; + tif->tif_rawdatasize = 0; + } tif->tif_flags &= ~TIFF_MYBUFFER; /* * We must check for overflow, potentially causing @@ -540,41 +844,58 @@ TIFFFillTile(TIFF* tif, ttile_t tile) * comparison (which can overflow) we do the following * two comparisons: */ - if (bytecount > tif->tif_size || - td->td_stripoffset[tile] > tif->tif_size - bytecount) { + if (bytecount > (uint64)tif->tif_size || + td->td_stripoffset[tile] > (uint64)tif->tif_size - bytecount) { tif->tif_curtile = NOTILE; return (0); } - tif->tif_rawdatasize = bytecount; + tif->tif_rawdatasize = (tmsize_t)bytecount; tif->tif_rawdata = - tif->tif_base + td->td_stripoffset[tile]; + tif->tif_base + (tmsize_t)td->td_stripoffset[tile]; + tif->tif_rawdataoff = 0; + tif->tif_rawdataloaded = (tmsize_t) bytecount; + tif->tif_flags |= TIFF_BUFFERMMAP; } else { /* * Expand raw data buffer, if needed, to hold data * tile coming from file (perhaps should set upper * bound on the size of a buffer we'll use?). */ - if (bytecount > (uint32)tif->tif_rawdatasize) { + tmsize_t bytecountm; + bytecountm=(tmsize_t)bytecount; + if ((uint64)bytecountm!=bytecount) + { + TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow"); + return(0); + } + if (bytecountm > tif->tif_rawdatasize) { tif->tif_curtile = NOTILE; if ((tif->tif_flags & TIFF_MYBUFFER) == 0) { - TIFFErrorExt(tif->tif_clientdata, - module, - "%s: Data buffer too small to hold tile %ld", - tif->tif_name, - (long) tile); + TIFFErrorExt(tif->tif_clientdata, module, + "Data buffer too small to hold tile %lu", + (unsigned long) tile); return (0); } - if (!TIFFReadBufferSetup(tif, 0, - TIFFroundup(bytecount, 1024))) + if (!TIFFReadBufferSetup(tif, 0, bytecountm)) return (0); } - if ((uint32)TIFFReadRawTile1(tif, tile, - (unsigned char *)tif->tif_rawdata, - bytecount, module) != bytecount) + if (tif->tif_flags&TIFF_BUFFERMMAP) { + tif->tif_curtile = NOTILE; + if (!TIFFReadBufferSetup(tif, 0, bytecountm)) + return (0); + } + + if (TIFFReadRawTile1(tif, tile, tif->tif_rawdata, + bytecountm, module) != bytecountm) return (0); + + tif->tif_rawdataoff = 0; + tif->tif_rawdataloaded = bytecountm; + if (!isFillOrder(tif, td->td_fillorder) && (tif->tif_flags & TIFF_NOBITREV) == 0) - TIFFReverseBits(tif->tif_rawdata, bytecount); + TIFFReverseBits(tif->tif_rawdata, + tif->tif_rawdataloaded); } } return (TIFFStartTile(tif, tile)); @@ -590,29 +911,34 @@ TIFFFillTile(TIFF* tif, ttile_t tile) * raw data. */ int -TIFFReadBufferSetup(TIFF* tif, tdata_t bp, tsize_t size) +TIFFReadBufferSetup(TIFF* tif, void* bp, tmsize_t size) { static const char module[] = "TIFFReadBufferSetup"; assert((tif->tif_flags&TIFF_NOREADRAW)==0); + tif->tif_flags &= ~TIFF_BUFFERMMAP; + if (tif->tif_rawdata) { if (tif->tif_flags & TIFF_MYBUFFER) _TIFFfree(tif->tif_rawdata); tif->tif_rawdata = NULL; + tif->tif_rawdatasize = 0; } if (bp) { tif->tif_rawdatasize = size; - tif->tif_rawdata = (tidata_t) bp; + tif->tif_rawdata = (uint8*) bp; tif->tif_flags &= ~TIFF_MYBUFFER; } else { - tif->tif_rawdatasize = TIFFroundup(size, 1024); - tif->tif_rawdata = (tidata_t) _TIFFmalloc(tif->tif_rawdatasize); + tif->tif_rawdatasize = (tmsize_t)TIFFroundup_64((uint64)size, 1024); + if (tif->tif_rawdatasize==0) + tif->tif_rawdatasize=(tmsize_t)(-1); + tif->tif_rawdata = (uint8*) _TIFFmalloc(tif->tif_rawdatasize); tif->tif_flags |= TIFF_MYBUFFER; } if (tif->tif_rawdata == NULL) { TIFFErrorExt(tif->tif_clientdata, module, - "%s: No space for data buffer at scanline %ld", - tif->tif_name, (long) tif->tif_row); + "No space for data buffer at scanline %lu", + (unsigned long) tif->tif_row); tif->tif_rawdatasize = 0; return (0); } @@ -624,10 +950,13 @@ TIFFReadBufferSetup(TIFF* tif, tdata_t bp, tsize_t size) * strip has just been read in. */ static int -TIFFStartStrip(TIFF* tif, tstrip_t strip) +TIFFStartStrip(TIFF* tif, uint32 strip) { TIFFDirectory *td = &tif->tif_dir; + if (!_TIFFFillStriles( tif ) || !tif->tif_dir.td_stripbytecount) + return 0; + if ((tif->tif_flags & TIFF_CODERSETUP) == 0) { if (!(*tif->tif_setupdecode)(tif)) return (0); @@ -635,18 +964,20 @@ TIFFStartStrip(TIFF* tif, tstrip_t strip) } tif->tif_curstrip = strip; tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip; + tif->tif_flags &= ~TIFF_BUF4WRITE; + if (tif->tif_flags&TIFF_NOREADRAW) { tif->tif_rawcp = NULL; - tif->tif_rawcc = 0; + tif->tif_rawcc = 0; } else { tif->tif_rawcp = tif->tif_rawdata; - tif->tif_rawcc = td->td_stripbytecount[strip]; + tif->tif_rawcc = (tmsize_t)td->td_stripbytecount[strip]; } return ((*tif->tif_predecode)(tif, - (tsample_t)(strip / td->td_stripsperimage))); + (uint16)(strip / td->td_stripsperimage))); } /* @@ -654,10 +985,13 @@ TIFFStartStrip(TIFF* tif, tstrip_t strip) * tile has just been read in. */ static int -TIFFStartTile(TIFF* tif, ttile_t tile) +TIFFStartTile(TIFF* tif, uint32 tile) { TIFFDirectory *td = &tif->tif_dir; + if (!_TIFFFillStriles( tif ) || !tif->tif_dir.td_stripbytecount) + return 0; + if ((tif->tif_flags & TIFF_CODERSETUP) == 0) { if (!(*tif->tif_setupdecode)(tif)) return (0); @@ -665,11 +999,12 @@ TIFFStartTile(TIFF* tif, ttile_t tile) } tif->tif_curtile = tile; tif->tif_row = - (tile % TIFFhowmany(td->td_imagewidth, td->td_tilewidth)) * + (tile % TIFFhowmany_32(td->td_imagewidth, td->td_tilewidth)) * td->td_tilelength; tif->tif_col = - (tile % TIFFhowmany(td->td_imagelength, td->td_tilelength)) * + (tile % TIFFhowmany_32(td->td_imagelength, td->td_tilelength)) * td->td_tilewidth; + tif->tif_flags &= ~TIFF_BUF4WRITE; if (tif->tif_flags&TIFF_NOREADRAW) { tif->tif_rawcp = NULL; @@ -678,10 +1013,10 @@ TIFFStartTile(TIFF* tif, ttile_t tile) else { tif->tif_rawcp = tif->tif_rawdata; - tif->tif_rawcc = td->td_stripbytecount[tile]; + tif->tif_rawcc = (tmsize_t)td->td_stripbytecount[tile]; } return ((*tif->tif_predecode)(tif, - (tsample_t)(tile/td->td_stripsperimage))); + (uint16)(tile/td->td_stripsperimage))); } static int @@ -701,13 +1036,13 @@ TIFFCheckRead(TIFF* tif, int tiles) } void -_TIFFNoPostDecode(TIFF* tif, tidata_t buf, tsize_t cc) +_TIFFNoPostDecode(TIFF* tif, uint8* buf, tmsize_t cc) { (void) tif; (void) buf; (void) cc; } void -_TIFFSwab16BitData(TIFF* tif, tidata_t buf, tsize_t cc) +_TIFFSwab16BitData(TIFF* tif, uint8* buf, tmsize_t cc) { (void) tif; assert((cc & 1) == 0); @@ -715,7 +1050,7 @@ _TIFFSwab16BitData(TIFF* tif, tidata_t buf, tsize_t cc) } void -_TIFFSwab24BitData(TIFF* tif, tidata_t buf, tsize_t cc) +_TIFFSwab24BitData(TIFF* tif, uint8* buf, tmsize_t cc) { (void) tif; assert((cc % 3) == 0); @@ -723,7 +1058,7 @@ _TIFFSwab24BitData(TIFF* tif, tidata_t buf, tsize_t cc) } void -_TIFFSwab32BitData(TIFF* tif, tidata_t buf, tsize_t cc) +_TIFFSwab32BitData(TIFF* tif, uint8* buf, tmsize_t cc) { (void) tif; assert((cc & 3) == 0); @@ -731,7 +1066,7 @@ _TIFFSwab32BitData(TIFF* tif, tidata_t buf, tsize_t cc) } void -_TIFFSwab64BitData(TIFF* tif, tidata_t buf, tsize_t cc) +_TIFFSwab64BitData(TIFF* tif, uint8* buf, tmsize_t cc) { (void) tif; assert((cc & 7) == 0); @@ -739,3 +1074,10 @@ _TIFFSwab64BitData(TIFF* tif, tidata_t buf, tsize_t cc) } /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_stream.cxx b/src/3rdparty/libtiff/libtiff/tif_stream.cxx index 2a2351b..163447e 100644 --- a/src/3rdparty/libtiff/libtiff/tif_stream.cxx +++ b/src/3rdparty/libtiff/libtiff/tif_stream.cxx @@ -1,4 +1,4 @@ -/* $Id: tif_stream.cxx,v 1.6.2.1 2009-01-01 00:10:43 bfriesen Exp $ */ +/* $Id: tif_stream.cxx,v 1.11 2010-12-11 23:12:29 faxguy Exp $ */ /* * Copyright (c) 1988-1996 Sam Leffler @@ -34,76 +34,166 @@ using namespace std; #endif -class tiffis_data +/* + ISO C++ uses a 'std::streamsize' type to define counts. This makes + it similar to, (but perhaps not the same as) size_t. + + The std::ios::pos_type is used to represent stream positions as used + by tellg(), tellp(), seekg(), and seekp(). This makes it similar to + (but perhaps not the same as) 'off_t'. The std::ios::streampos type + is used for character streams, but is documented to not be an + integral type anymore, so it should *not* be assigned to an integral + type. + + The std::ios::off_type is used to specify relative offsets needed by + the variants of seekg() and seekp() which accept a relative offset + argument. + + Useful prototype knowledge: + + Obtain read position + ios::pos_type basic_istream::tellg() + + Set read position + basic_istream& basic_istream::seekg(ios::pos_type) + basic_istream& basic_istream::seekg(ios::off_type, ios_base::seekdir) + + Read data + basic_istream& istream::read(char *str, streamsize count) + + Number of characters read in last unformatted read + streamsize istream::gcount(); + + Obtain write position + ios::pos_type basic_ostream::tellp() + + Set write position + basic_ostream& basic_ostream::seekp(ios::pos_type) + basic_ostream& basic_ostream::seekp(ios::off_type, ios_base::seekdir) + + Write data + basic_ostream& ostream::write(const char *str, streamsize count) +*/ + +struct tiffis_data; +struct tiffos_data; + +extern "C" { + + static tmsize_t _tiffosReadProc(thandle_t, void*, tmsize_t); + static tmsize_t _tiffisReadProc(thandle_t fd, void* buf, tmsize_t size); + static tmsize_t _tiffosWriteProc(thandle_t fd, void* buf, tmsize_t size); + static tmsize_t _tiffisWriteProc(thandle_t, void*, tmsize_t); + static uint64 _tiffosSeekProc(thandle_t fd, uint64 off, int whence); + static uint64 _tiffisSeekProc(thandle_t fd, uint64 off, int whence); + static uint64 _tiffosSizeProc(thandle_t fd); + static uint64 _tiffisSizeProc(thandle_t fd); + static int _tiffosCloseProc(thandle_t fd); + static int _tiffisCloseProc(thandle_t fd); + static int _tiffDummyMapProc(thandle_t , void** base, toff_t* size ); + static void _tiffDummyUnmapProc(thandle_t , void* base, toff_t size ); + static TIFF* _tiffStreamOpen(const char* name, const char* mode, void *fd); + +struct tiffis_data { - public: - - istream *myIS; - long myStreamStartPos; + istream *stream; + ios::pos_type start_pos; }; -class tiffos_data +struct tiffos_data { - public: - - ostream *myOS; - long myStreamStartPos; + ostream *stream; + ios::pos_type start_pos; }; -static tsize_t -_tiffosReadProc(thandle_t, tdata_t, tsize_t) +static tmsize_t +_tiffosReadProc(thandle_t, void*, tmsize_t) { return 0; } -static tsize_t -_tiffisReadProc(thandle_t fd, tdata_t buf, tsize_t size) +static tmsize_t +_tiffisReadProc(thandle_t fd, void* buf, tmsize_t size) { - tiffis_data *data = (tiffis_data *)fd; + tiffis_data *data = reinterpret_cast<tiffis_data *>(fd); - data->myIS->read((char *)buf, (int)size); + // Verify that type does not overflow. + streamsize request_size = size; + if (static_cast<tmsize_t>(request_size) != size) + return static_cast<tmsize_t>(-1); - return data->myIS->gcount(); + data->stream->read((char *) buf, request_size); + + return static_cast<tmsize_t>(data->stream->gcount()); } -static tsize_t -_tiffosWriteProc(thandle_t fd, tdata_t buf, tsize_t size) +static tmsize_t +_tiffosWriteProc(thandle_t fd, void* buf, tmsize_t size) { - tiffos_data *data = (tiffos_data *)fd; - ostream *os = data->myOS; - int pos = os->tellp(); + tiffos_data *data = reinterpret_cast<tiffos_data *>(fd); + ostream *os = data->stream; + ios::pos_type pos = os->tellp(); + + // Verify that type does not overflow. + streamsize request_size = size; + if (static_cast<tmsize_t>(request_size) != size) + return static_cast<tmsize_t>(-1); - os->write((const char *)buf, size); + os->write(reinterpret_cast<const char *>(buf), request_size); - return ((int)os->tellp()) - pos; + return static_cast<tmsize_t>(os->tellp() - pos); } -static tsize_t -_tiffisWriteProc(thandle_t, tdata_t, tsize_t) +static tmsize_t +_tiffisWriteProc(thandle_t, void*, tmsize_t) { return 0; } -static toff_t -_tiffosSeekProc(thandle_t fd, toff_t off, int whence) +static uint64 +_tiffosSeekProc(thandle_t fd, uint64 off, int whence) { - tiffos_data *data = (tiffos_data *)fd; - ostream *os = data->myOS; + tiffos_data *data = reinterpret_cast<tiffos_data *>(fd); + ostream *os = data->stream; // if the stream has already failed, don't do anything if( os->fail() ) - return os->tellp(); + return static_cast<uint64>(-1); switch(whence) { case SEEK_SET: - os->seekp(data->myStreamStartPos + off, ios::beg); + { + // Compute 64-bit offset + uint64 new_offset = static_cast<uint64>(data->start_pos) + off; + + // Verify that value does not overflow + ios::off_type offset = static_cast<ios::off_type>(new_offset); + if (static_cast<uint64>(offset) != new_offset) + return static_cast<uint64>(-1); + + os->seekp(offset, ios::beg); break; + } case SEEK_CUR: - os->seekp(off, ios::cur); - break; + { + // Verify that value does not overflow + ios::off_type offset = static_cast<ios::off_type>(off); + if (static_cast<uint64>(offset) != off) + return static_cast<uint64>(-1); + + os->seekp(offset, ios::cur); + break; + } case SEEK_END: - os->seekp(off, ios::end); - break; + { + // Verify that value does not overflow + ios::off_type offset = static_cast<ios::off_type>(off); + if (static_cast<uint64>(offset) != off) + return static_cast<uint64>(-1); + + os->seekp(offset, ios::end); + break; + } } // Attempt to workaround problems with seeking past the end of the @@ -116,14 +206,15 @@ _tiffosSeekProc(thandle_t fd, toff_t off, int whence) #else ios::iostate old_state; #endif - toff_t origin=0; + ios::pos_type origin; old_state = os->rdstate(); // reset the fail bit or else tellp() won't work below os->clear(os->rdstate() & ~ios::failbit); switch( whence ) { case SEEK_SET: - origin = data->myStreamStartPos; + default: + origin = data->start_pos; break; case SEEK_CUR: origin = os->tellp(); @@ -137,80 +228,104 @@ _tiffosSeekProc(thandle_t fd, toff_t off, int whence) os->clear(old_state); // only do something if desired seek position is valid - if( origin + off > data->myStreamStartPos ) { - toff_t num_fill; + if( (static_cast<uint64>(origin) + off) > static_cast<uint64>(data->start_pos) ) { + uint64 num_fill; // clear the fail bit os->clear(os->rdstate() & ~ios::failbit); // extend the stream to the expected size os->seekp(0, ios::end); - num_fill = origin + off - (toff_t)os->tellp(); - for( toff_t i = 0; i < num_fill; i++ ) + num_fill = (static_cast<uint64>(origin)) + off - os->tellp(); + for( uint64 i = 0; i < num_fill; i++ ) os->put('\0'); // retry the seek - os->seekp(origin + off, ios::beg); + os->seekp(static_cast<ios::off_type>(static_cast<uint64>(origin) + off), ios::beg); } } - return os->tellp(); + return static_cast<uint64>(os->tellp()); } -static toff_t -_tiffisSeekProc(thandle_t fd, toff_t off, int whence) +static uint64 +_tiffisSeekProc(thandle_t fd, uint64 off, int whence) { - tiffis_data *data = (tiffis_data *)fd; + tiffis_data *data = reinterpret_cast<tiffis_data *>(fd); switch(whence) { case SEEK_SET: - data->myIS->seekg(data->myStreamStartPos + off, ios::beg); - break; + { + // Compute 64-bit offset + uint64 new_offset = static_cast<uint64>(data->start_pos) + off; + + // Verify that value does not overflow + ios::off_type offset = static_cast<ios::off_type>(new_offset); + if (static_cast<uint64>(offset) != new_offset) + return static_cast<uint64>(-1); + + data->stream->seekg(offset, ios::beg); + break; + } case SEEK_CUR: - data->myIS->seekg(off, ios::cur); - break; + { + // Verify that value does not overflow + ios::off_type offset = static_cast<ios::off_type>(off); + if (static_cast<uint64>(offset) != off) + return static_cast<uint64>(-1); + + data->stream->seekg(offset, ios::cur); + break; + } case SEEK_END: - data->myIS->seekg(off, ios::end); - break; + { + // Verify that value does not overflow + ios::off_type offset = static_cast<ios::off_type>(off); + if (static_cast<uint64>(offset) != off) + return static_cast<uint64>(-1); + + data->stream->seekg(offset, ios::end); + break; + } } - return ((long)data->myIS->tellg()) - data->myStreamStartPos; + return (uint64) (data->stream->tellg() - data->start_pos); } -static toff_t +static uint64 _tiffosSizeProc(thandle_t fd) { - tiffos_data *data = (tiffos_data *)fd; - ostream *os = data->myOS; - toff_t pos = os->tellp(); - toff_t len; + tiffos_data *data = reinterpret_cast<tiffos_data *>(fd); + ostream *os = data->stream; + ios::pos_type pos = os->tellp(); + ios::pos_type len; os->seekp(0, ios::end); len = os->tellp(); os->seekp(pos); - return len; + return (uint64) len; } -static toff_t +static uint64 _tiffisSizeProc(thandle_t fd) { - tiffis_data *data = (tiffis_data *)fd; - int pos = data->myIS->tellg(); - int len; + tiffis_data *data = reinterpret_cast<tiffis_data *>(fd); + ios::pos_type pos = data->stream->tellg(); + ios::pos_type len; - data->myIS->seekg(0, ios::end); - len = data->myIS->tellg(); - data->myIS->seekg(pos); + data->stream->seekg(0, ios::end); + len = data->stream->tellg(); + data->stream->seekg(pos); - return len; + return (uint64) len; } static int _tiffosCloseProc(thandle_t fd) { // Our stream was not allocated by us, so it shouldn't be closed by us. - delete (tiffos_data *)fd; + delete reinterpret_cast<tiffos_data *>(fd); return 0; } @@ -218,18 +333,18 @@ static int _tiffisCloseProc(thandle_t fd) { // Our stream was not allocated by us, so it shouldn't be closed by us. - delete (tiffis_data *)fd; + delete reinterpret_cast<tiffis_data *>(fd); return 0; } static int -_tiffDummyMapProc(thandle_t , tdata_t* , toff_t* ) +_tiffDummyMapProc(thandle_t , void** base, toff_t* size ) { return (0); } static void -_tiffDummyUnmapProc(thandle_t , tdata_t , toff_t ) +_tiffDummyUnmapProc(thandle_t , void* base, toff_t size ) { } @@ -243,32 +358,40 @@ _tiffStreamOpen(const char* name, const char* mode, void *fd) if( strchr(mode, 'w') ) { tiffos_data *data = new tiffos_data; - data->myOS = (ostream *)fd; - data->myStreamStartPos = data->myOS->tellp(); + data->stream = reinterpret_cast<ostream *>(fd); + data->start_pos = data->stream->tellp(); // Open for writing. tif = TIFFClientOpen(name, mode, - (thandle_t) data, - _tiffosReadProc, _tiffosWriteProc, - _tiffosSeekProc, _tiffosCloseProc, + reinterpret_cast<thandle_t>(data), + _tiffosReadProc, + _tiffosWriteProc, + _tiffosSeekProc, + _tiffosCloseProc, _tiffosSizeProc, - _tiffDummyMapProc, _tiffDummyUnmapProc); + _tiffDummyMapProc, + _tiffDummyUnmapProc); } else { tiffis_data *data = new tiffis_data; - data->myIS = (istream *)fd; - data->myStreamStartPos = data->myIS->tellg(); + data->stream = reinterpret_cast<istream *>(fd); + data->start_pos = data->stream->tellg(); // Open for reading. tif = TIFFClientOpen(name, mode, - (thandle_t) data, - _tiffisReadProc, _tiffisWriteProc, - _tiffisSeekProc, _tiffisCloseProc, + reinterpret_cast<thandle_t>(data), + _tiffisReadProc, + _tiffisWriteProc, + _tiffisSeekProc, + _tiffisCloseProc, _tiffisSizeProc, - _tiffDummyMapProc, _tiffDummyUnmapProc); + _tiffDummyMapProc, + _tiffDummyUnmapProc); } return (tif); } +} /* extern "C" */ + TIFF* TIFFStreamOpen(const char* name, ostream *os) { @@ -276,7 +399,7 @@ TIFFStreamOpen(const char* name, ostream *os) // written to it yet, then tellp() will return -1 which will break us. // We workaround this by writing out a dummy character and // then seek back to the beginning. - if( !os->fail() && (int)os->tellp() < 0 ) { + if( !os->fail() && static_cast<int>(os->tellp()) < 0 ) { *os << '\0'; os->seekp(0); } @@ -293,3 +416,10 @@ TIFFStreamOpen(const char* name, istream *is) } /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + Local Variables: + mode: c + indent-tabs-mode: true + c-basic-offset: 8 + End: +*/ diff --git a/src/3rdparty/libtiff/libtiff/tif_strip.c b/src/3rdparty/libtiff/libtiff/tif_strip.c index 962d3fa..568e489 100644 --- a/src/3rdparty/libtiff/libtiff/tif_strip.c +++ b/src/3rdparty/libtiff/libtiff/tif_strip.c @@ -1,4 +1,4 @@ -/* $Id: tif_strip.c,v 1.19 2006/03/25 18:04:35 joris Exp $ */ +/* $Id: tif_strip.c,v 1.35 2012-06-06 05:33:55 fwarmerdam Exp $ */ /* * Copyright (c) 1991-1997 Sam Leffler @@ -31,54 +31,25 @@ */ #include "tiffiop.h" -static uint32 -summarize(TIFF* tif, size_t summand1, size_t summand2, const char* where) -{ - /* - * XXX: We are using casting to uint32 here, bacause sizeof(size_t) - * may be larger than sizeof(uint32) on 64-bit architectures. - */ - uint32 bytes = summand1 + summand2; - - if (bytes - summand1 != summand2) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Integer overflow in %s", where); - bytes = 0; - } - - return (bytes); -} - -static uint32 -multiply(TIFF* tif, size_t nmemb, size_t elem_size, const char* where) -{ - uint32 bytes = nmemb * elem_size; - - if (elem_size && bytes / elem_size != nmemb) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Integer overflow in %s", where); - bytes = 0; - } - - return (bytes); -} - /* * Compute which strip a (row,sample) value is in. */ -tstrip_t -TIFFComputeStrip(TIFF* tif, uint32 row, tsample_t sample) +uint32 +TIFFComputeStrip(TIFF* tif, uint32 row, uint16 sample) { + static const char module[] = "TIFFComputeStrip"; TIFFDirectory *td = &tif->tif_dir; - tstrip_t strip; + uint32 strip; strip = row / td->td_rowsperstrip; if (td->td_planarconfig == PLANARCONFIG_SEPARATE) { if (sample >= td->td_samplesperpixel) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, + TIFFErrorExt(tif->tif_clientdata, module, "%lu: Sample out of range, max %lu", (unsigned long) sample, (unsigned long) td->td_samplesperpixel); - return ((tstrip_t) 0); + return (0); } - strip += sample*td->td_stripsperimage; + strip += (uint32)sample*td->td_stripsperimage; } return (strip); } @@ -86,33 +57,34 @@ TIFFComputeStrip(TIFF* tif, uint32 row, tsample_t sample) /* * Compute how many strips are in an image. */ -tstrip_t +uint32 TIFFNumberOfStrips(TIFF* tif) { TIFFDirectory *td = &tif->tif_dir; - tstrip_t nstrips; + uint32 nstrips; nstrips = (td->td_rowsperstrip == (uint32) -1 ? 1 : - TIFFhowmany(td->td_imagelength, td->td_rowsperstrip)); + TIFFhowmany_32(td->td_imagelength, td->td_rowsperstrip)); if (td->td_planarconfig == PLANARCONFIG_SEPARATE) - nstrips = multiply(tif, nstrips, td->td_samplesperpixel, - "TIFFNumberOfStrips"); + nstrips = _TIFFMultiply32(tif, nstrips, (uint32)td->td_samplesperpixel, + "TIFFNumberOfStrips"); return (nstrips); } /* * Compute the # bytes in a variable height, row-aligned strip. */ -tsize_t -TIFFVStripSize(TIFF* tif, uint32 nrows) +uint64 +TIFFVStripSize64(TIFF* tif, uint32 nrows) { + static const char module[] = "TIFFVStripSize64"; TIFFDirectory *td = &tif->tif_dir; - - if (nrows == (uint32) -1) - nrows = td->td_imagelength; - if (td->td_planarconfig == PLANARCONFIG_CONTIG && - td->td_photometric == PHOTOMETRIC_YCBCR && - !isUpSampled(tif)) { + if (nrows==(uint32)(-1)) + nrows=td->td_imagelength; + if ((td->td_planarconfig==PLANARCONFIG_CONTIG)&& + (td->td_photometric == PHOTOMETRIC_YCBCR)&& + (!isUpSampled(tif))) + { /* * Packed YCbCr data contain one Cb+Cr for every * HorizontalSampling*VerticalSampling Y values. @@ -122,53 +94,102 @@ TIFFVStripSize(TIFF* tif, uint32 nrows) * YCbCr data for the extended image. */ uint16 ycbcrsubsampling[2]; - tsize_t w, scanline, samplingarea; - - TIFFGetField( tif, TIFFTAG_YCBCRSUBSAMPLING, - ycbcrsubsampling + 0, - ycbcrsubsampling + 1 ); - - samplingarea = ycbcrsubsampling[0]*ycbcrsubsampling[1]; - if (samplingarea == 0) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Invalid YCbCr subsampling"); + uint16 samplingblock_samples; + uint32 samplingblocks_hor; + uint32 samplingblocks_ver; + uint64 samplingrow_samples; + uint64 samplingrow_size; + if(td->td_samplesperpixel!=3) + { + TIFFErrorExt(tif->tif_clientdata,module, + "Invalid td_samplesperpixel value"); return 0; } - - w = TIFFroundup(td->td_imagewidth, ycbcrsubsampling[0]); - scanline = TIFFhowmany8(multiply(tif, w, td->td_bitspersample, - "TIFFVStripSize")); - nrows = TIFFroundup(nrows, ycbcrsubsampling[1]); - /* NB: don't need TIFFhowmany here 'cuz everything is rounded */ - scanline = multiply(tif, nrows, scanline, "TIFFVStripSize"); - return ((tsize_t) - summarize(tif, scanline, - multiply(tif, 2, scanline / samplingarea, - "TIFFVStripSize"), "TIFFVStripSize")); - } else - return ((tsize_t) multiply(tif, nrows, TIFFScanlineSize(tif), - "TIFFVStripSize")); + TIFFGetFieldDefaulted(tif,TIFFTAG_YCBCRSUBSAMPLING,ycbcrsubsampling+0, + ycbcrsubsampling+1); + if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 && ycbcrsubsampling[0] != 4) + ||(ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 && ycbcrsubsampling[1] != 4)) + { + TIFFErrorExt(tif->tif_clientdata,module, + "Invalid YCbCr subsampling (%dx%d)", + ycbcrsubsampling[0], + ycbcrsubsampling[1] ); + return 0; + } + samplingblock_samples=ycbcrsubsampling[0]*ycbcrsubsampling[1]+2; + samplingblocks_hor=TIFFhowmany_32(td->td_imagewidth,ycbcrsubsampling[0]); + samplingblocks_ver=TIFFhowmany_32(nrows,ycbcrsubsampling[1]); + samplingrow_samples=_TIFFMultiply64(tif,samplingblocks_hor,samplingblock_samples,module); + samplingrow_size=TIFFhowmany8_64(_TIFFMultiply64(tif,samplingrow_samples,td->td_bitspersample,module)); + return(_TIFFMultiply64(tif,samplingrow_size,samplingblocks_ver,module)); + } + else + return(_TIFFMultiply64(tif,nrows,TIFFScanlineSize64(tif),module)); +} +tmsize_t +TIFFVStripSize(TIFF* tif, uint32 nrows) +{ + static const char module[] = "TIFFVStripSize"; + uint64 m; + tmsize_t n; + m=TIFFVStripSize64(tif,nrows); + n=(tmsize_t)m; + if ((uint64)n!=m) + { + TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow"); + n=0; + } + return(n); } - /* * Compute the # bytes in a raw strip. */ -tsize_t -TIFFRawStripSize(TIFF* tif, tstrip_t strip) +uint64 +TIFFRawStripSize64(TIFF* tif, uint32 strip) { + static const char module[] = "TIFFRawStripSize64"; TIFFDirectory* td = &tif->tif_dir; - tsize_t bytecount = td->td_stripbytecount[strip]; - - if (bytecount <= 0) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "%lu: Invalid strip byte count, strip %lu", - (unsigned long) bytecount, (unsigned long) strip); - bytecount = (tsize_t) -1; + uint64 bytecount = td->td_stripbytecount[strip]; + + if (bytecount == 0) + { +#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) + TIFFErrorExt(tif->tif_clientdata, module, + "%I64u: Invalid strip byte count, strip %lu", + (unsigned __int64) bytecount, + (unsigned long) strip); +#else + TIFFErrorExt(tif->tif_clientdata, module, + "%llu: Invalid strip byte count, strip %lu", + (unsigned long long) bytecount, + (unsigned long) strip); +#endif + bytecount = (uint64) -1; } return bytecount; } +tmsize_t +TIFFRawStripSize(TIFF* tif, uint32 strip) +{ + static const char module[] = "TIFFRawStripSize"; + uint64 m; + tmsize_t n; + m=TIFFRawStripSize64(tif,strip); + if (m==(uint64)(-1)) + n=(tmsize_t)(-1); + else + { + n=(tmsize_t)m; + if ((uint64)n!=m) + { + TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow"); + n=0; + } + } + return(n); +} /* * Compute the # bytes in a (row-aligned) strip. @@ -178,14 +199,29 @@ TIFFRawStripSize(TIFF* tif, tstrip_t strip) * truncated to reflect the actual space required * to hold the strip. */ -tsize_t -TIFFStripSize(TIFF* tif) +uint64 +TIFFStripSize64(TIFF* tif) { TIFFDirectory* td = &tif->tif_dir; uint32 rps = td->td_rowsperstrip; if (rps > td->td_imagelength) rps = td->td_imagelength; - return (TIFFVStripSize(tif, rps)); + return (TIFFVStripSize64(tif, rps)); +} +tmsize_t +TIFFStripSize(TIFF* tif) +{ + static const char module[] = "TIFFStripSize"; + uint64 m; + tmsize_t n; + m=TIFFStripSize64(tif); + n=(tmsize_t)m; + if ((uint64)n!=m) + { + TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow"); + n=0; + } + return(n); } /* @@ -209,10 +245,17 @@ _TIFFDefaultStripSize(TIFF* tif, uint32 s) * image up into strips that are approximately * STRIP_SIZE_DEFAULT bytes long. */ - tsize_t scanline = TIFFScanlineSize(tif); - s = (uint32)STRIP_SIZE_DEFAULT / (scanline == 0 ? 1 : scanline); - if (s == 0) /* very wide images */ - s = 1; + uint64 scanlinesize; + uint64 rows; + scanlinesize=TIFFScanlineSize64(tif); + if (scanlinesize==0) + scanlinesize=1; + rows=(uint64)STRIP_SIZE_DEFAULT/scanlinesize; + if (rows==0) + rows=1; + else if (rows>0xFFFFFFFF) + rows=0xFFFFFFFF; + s=(uint32)rows; } return (s); } @@ -222,118 +265,75 @@ _TIFFDefaultStripSize(TIFF* tif, uint32 s) * one of the scanline-oriented i/o routines. Note that * this number may be 1/samples-per-pixel if data is * stored as separate planes. - */ -tsize_t -TIFFScanlineSize(TIFF* tif) -{ - TIFFDirectory *td = &tif->tif_dir; - tsize_t scanline; - - if (td->td_planarconfig == PLANARCONFIG_CONTIG) { - if (td->td_photometric == PHOTOMETRIC_YCBCR - && !isUpSampled(tif)) { - uint16 ycbcrsubsampling[2]; - - TIFFGetField(tif, TIFFTAG_YCBCRSUBSAMPLING, - ycbcrsubsampling + 0, - ycbcrsubsampling + 1); - - if (ycbcrsubsampling[0] == 0) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Invalid YCbCr subsampling"); - return 0; - } - - scanline = TIFFroundup(td->td_imagewidth, - ycbcrsubsampling[0]); - scanline = TIFFhowmany8(multiply(tif, scanline, - td->td_bitspersample, - "TIFFScanlineSize")); - return ((tsize_t) - summarize(tif, scanline, - multiply(tif, 2, - scanline / ycbcrsubsampling[0], - "TIFFVStripSize"), - "TIFFVStripSize")); - } else { - scanline = multiply(tif, td->td_imagewidth, - td->td_samplesperpixel, - "TIFFScanlineSize"); - } - } else - scanline = td->td_imagewidth; - return ((tsize_t) TIFFhowmany8(multiply(tif, scanline, - td->td_bitspersample, - "TIFFScanlineSize"))); -} - -/* - * Some stuff depends on this older version of TIFFScanlineSize - * TODO: resolve this - */ -tsize_t -TIFFOldScanlineSize(TIFF* tif) -{ - TIFFDirectory *td = &tif->tif_dir; - tsize_t scanline; - - scanline = multiply (tif, td->td_bitspersample, td->td_imagewidth, - "TIFFScanlineSize"); - if (td->td_planarconfig == PLANARCONFIG_CONTIG) - scanline = multiply (tif, scanline, td->td_samplesperpixel, - "TIFFScanlineSize"); - return ((tsize_t) TIFFhowmany8(scanline)); -} - -/* - * Return the number of bytes to read/write in a call to - * one of the scanline-oriented i/o routines. Note that - * this number may be 1/samples-per-pixel if data is - * stored as separate planes. * The ScanlineSize in case of YCbCrSubsampling is defined as the * strip size divided by the strip height, i.e. the size of a pack of vertical * subsampling lines divided by vertical subsampling. It should thus make * sense when multiplied by a multiple of vertical subsampling. - * Some stuff depends on this newer version of TIFFScanlineSize - * TODO: resolve this */ -tsize_t -TIFFNewScanlineSize(TIFF* tif) +uint64 +TIFFScanlineSize64(TIFF* tif) { + static const char module[] = "TIFFScanlineSize64"; TIFFDirectory *td = &tif->tif_dir; - tsize_t scanline; - - if (td->td_planarconfig == PLANARCONFIG_CONTIG) { - if (td->td_photometric == PHOTOMETRIC_YCBCR - && !isUpSampled(tif)) { + uint64 scanline_size; + if (td->td_planarconfig==PLANARCONFIG_CONTIG) + { + if ((td->td_photometric==PHOTOMETRIC_YCBCR)&& + (td->td_samplesperpixel==3)&& + (!isUpSampled(tif))) + { uint16 ycbcrsubsampling[2]; - - TIFFGetField(tif, TIFFTAG_YCBCRSUBSAMPLING, - ycbcrsubsampling + 0, - ycbcrsubsampling + 1); - - if (ycbcrsubsampling[0]*ycbcrsubsampling[1] == 0) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Invalid YCbCr subsampling"); - return 0; + uint16 samplingblock_samples; + uint32 samplingblocks_hor; + uint64 samplingrow_samples; + uint64 samplingrow_size; + if(td->td_samplesperpixel!=3) + { + TIFFErrorExt(tif->tif_clientdata,module, + "Invalid td_samplesperpixel value"); + return 0; } - - return((tsize_t) ((((td->td_imagewidth+ycbcrsubsampling[0]-1) - /ycbcrsubsampling[0]) - *(ycbcrsubsampling[0]*ycbcrsubsampling[1]+2) - *td->td_bitspersample+7) - /8)/ycbcrsubsampling[1]); - - } else { - scanline = multiply(tif, td->td_imagewidth, - td->td_samplesperpixel, - "TIFFScanlineSize"); + TIFFGetFieldDefaulted(tif,TIFFTAG_YCBCRSUBSAMPLING, + ycbcrsubsampling+0, + ycbcrsubsampling+1); + if (((ycbcrsubsampling[0]!=1)&&(ycbcrsubsampling[0]!=2)&&(ycbcrsubsampling[0]!=4)) || + ((ycbcrsubsampling[1]!=1)&&(ycbcrsubsampling[1]!=2)&&(ycbcrsubsampling[1]!=4))) + { + TIFFErrorExt(tif->tif_clientdata,module, + "Invalid YCbCr subsampling"); + return 0; + } + samplingblock_samples = ycbcrsubsampling[0]*ycbcrsubsampling[1]+2; + samplingblocks_hor = TIFFhowmany_32(td->td_imagewidth,ycbcrsubsampling[0]); + samplingrow_samples = _TIFFMultiply64(tif,samplingblocks_hor,samplingblock_samples,module); + samplingrow_size = TIFFhowmany_64(_TIFFMultiply64(tif,samplingrow_samples,td->td_bitspersample,module),8); + scanline_size = (samplingrow_size/ycbcrsubsampling[1]); } - } else - scanline = td->td_imagewidth; - return ((tsize_t) TIFFhowmany8(multiply(tif, scanline, - td->td_bitspersample, - "TIFFScanlineSize"))); + else + { + uint64 scanline_samples; + scanline_samples=_TIFFMultiply64(tif,td->td_imagewidth,td->td_samplesperpixel,module); + scanline_size=TIFFhowmany_64(_TIFFMultiply64(tif,scanline_samples,td->td_bitspersample,module),8); + } + } + else + scanline_size=TIFFhowmany_64(_TIFFMultiply64(tif,td->td_imagewidth,td->td_bitspersample,module),8); + return(scanline_size); +} +tmsize_t +TIFFScanlineSize(TIFF* tif) +{ + static const char module[] = "TIFFScanlineSize"; + uint64 m; + tmsize_t n; + m=TIFFScanlineSize64(tif); + n=(tmsize_t)m; + if ((uint64)n!=m) + { + TIFFErrorExt(tif->tif_clientdata,module,"Integer arithmetic overflow"); + n=0; + } + return(n); } /* @@ -342,22 +342,42 @@ TIFFNewScanlineSize(TIFF* tif) * I/O size returned by TIFFScanlineSize which may be less * if data is store as separate planes). */ -tsize_t -TIFFRasterScanlineSize(TIFF* tif) +uint64 +TIFFRasterScanlineSize64(TIFF* tif) { + static const char module[] = "TIFFRasterScanlineSize64"; TIFFDirectory *td = &tif->tif_dir; - tsize_t scanline; - - scanline = multiply (tif, td->td_bitspersample, td->td_imagewidth, - "TIFFRasterScanlineSize"); + uint64 scanline; + + scanline = _TIFFMultiply64(tif, td->td_bitspersample, td->td_imagewidth, module); if (td->td_planarconfig == PLANARCONFIG_CONTIG) { - scanline = multiply (tif, scanline, td->td_samplesperpixel, - "TIFFRasterScanlineSize"); - return ((tsize_t) TIFFhowmany8(scanline)); + scanline = _TIFFMultiply64(tif, scanline, td->td_samplesperpixel, module); + return (TIFFhowmany8_64(scanline)); } else - return ((tsize_t) multiply (tif, TIFFhowmany8(scanline), - td->td_samplesperpixel, - "TIFFRasterScanlineSize")); + return (_TIFFMultiply64(tif, TIFFhowmany8_64(scanline), + td->td_samplesperpixel, module)); +} +tmsize_t +TIFFRasterScanlineSize(TIFF* tif) +{ + static const char module[] = "TIFFRasterScanlineSize"; + uint64 m; + tmsize_t n; + m=TIFFRasterScanlineSize64(tif); + n=(tmsize_t)m; + if ((uint64)n!=m) + { + TIFFErrorExt(tif->tif_clientdata,module,"Integer arithmetic overflow"); + n=0; + } + return(n); } /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_swab.c b/src/3rdparty/libtiff/libtiff/tif_swab.c index 97cc888..f37e33f 100644 --- a/src/3rdparty/libtiff/libtiff/tif_swab.c +++ b/src/3rdparty/libtiff/libtiff/tif_swab.c @@ -1,4 +1,4 @@ -/* $Id: tif_swab.c,v 1.4 2005/04/13 14:06:21 dron Exp $ */ +/* $Id: tif_swab.c,v 1.13 2010-03-10 18:56:49 bfriesen Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler @@ -37,7 +37,7 @@ TIFFSwabShort(uint16* wp) { register unsigned char* cp = (unsigned char*) wp; unsigned char t; - + assert(sizeof(uint16)==2); t = cp[1]; cp[1] = cp[0]; cp[0] = t; } #endif @@ -48,19 +48,33 @@ TIFFSwabLong(uint32* lp) { register unsigned char* cp = (unsigned char*) lp; unsigned char t; - + assert(sizeof(uint32)==4); t = cp[3]; cp[3] = cp[0]; cp[0] = t; t = cp[2]; cp[2] = cp[1]; cp[1] = t; } #endif +#ifndef TIFFSwabLong8 +void +TIFFSwabLong8(uint64* lp) +{ + register unsigned char* cp = (unsigned char*) lp; + unsigned char t; + assert(sizeof(uint64)==8); + t = cp[7]; cp[7] = cp[0]; cp[0] = t; + t = cp[6]; cp[6] = cp[1]; cp[1] = t; + t = cp[5]; cp[5] = cp[2]; cp[2] = t; + t = cp[4]; cp[4] = cp[3]; cp[3] = t; +} +#endif + #ifndef TIFFSwabArrayOfShort void -TIFFSwabArrayOfShort(uint16* wp, register unsigned long n) +TIFFSwabArrayOfShort(register uint16* wp, tmsize_t n) { register unsigned char* cp; register unsigned char t; - + assert(sizeof(uint16)==2); /* XXX unroll loop some */ while (n-- > 0) { cp = (unsigned char*) wp; @@ -72,7 +86,7 @@ TIFFSwabArrayOfShort(uint16* wp, register unsigned long n) #ifndef TIFFSwabArrayOfTriples void -TIFFSwabArrayOfTriples(uint8* tp, unsigned long n) +TIFFSwabArrayOfTriples(register uint8* tp, tmsize_t n) { unsigned char* cp; unsigned char t; @@ -88,11 +102,11 @@ TIFFSwabArrayOfTriples(uint8* tp, unsigned long n) #ifndef TIFFSwabArrayOfLong void -TIFFSwabArrayOfLong(register uint32* lp, register unsigned long n) +TIFFSwabArrayOfLong(register uint32* lp, tmsize_t n) { register unsigned char *cp; register unsigned char t; - + assert(sizeof(uint32)==4); /* XXX unroll loop some */ while (n-- > 0) { cp = (unsigned char *)lp; @@ -103,30 +117,84 @@ TIFFSwabArrayOfLong(register uint32* lp, register unsigned long n) } #endif +#ifndef TIFFSwabArrayOfLong8 +void +TIFFSwabArrayOfLong8(register uint64* lp, tmsize_t n) +{ + register unsigned char *cp; + register unsigned char t; + assert(sizeof(uint64)==8); + /* XXX unroll loop some */ + while (n-- > 0) { + cp = (unsigned char *)lp; + t = cp[7]; cp[7] = cp[0]; cp[0] = t; + t = cp[6]; cp[6] = cp[1]; cp[1] = t; + t = cp[5]; cp[5] = cp[2]; cp[2] = t; + t = cp[4]; cp[4] = cp[3]; cp[3] = t; + lp++; + } +} +#endif + +#ifndef TIFFSwabFloat +void +TIFFSwabFloat(float* fp) +{ + register unsigned char* cp = (unsigned char*) fp; + unsigned char t; + assert(sizeof(float)==4); + t = cp[3]; cp[3] = cp[0]; cp[0] = t; + t = cp[2]; cp[2] = cp[1]; cp[1] = t; +} +#endif + +#ifndef TIFFSwabArrayOfFloat +void +TIFFSwabArrayOfFloat(register float* fp, tmsize_t n) +{ + register unsigned char *cp; + register unsigned char t; + assert(sizeof(float)==4); + /* XXX unroll loop some */ + while (n-- > 0) { + cp = (unsigned char *)fp; + t = cp[3]; cp[3] = cp[0]; cp[0] = t; + t = cp[2]; cp[2] = cp[1]; cp[1] = t; + fp++; + } +} +#endif + #ifndef TIFFSwabDouble void TIFFSwabDouble(double *dp) { - register uint32* lp = (uint32*) dp; - uint32 t; - - TIFFSwabArrayOfLong(lp, 2); - t = lp[0]; lp[0] = lp[1]; lp[1] = t; + register unsigned char* cp = (unsigned char*) dp; + unsigned char t; + assert(sizeof(double)==8); + t = cp[7]; cp[7] = cp[0]; cp[0] = t; + t = cp[6]; cp[6] = cp[1]; cp[1] = t; + t = cp[5]; cp[5] = cp[2]; cp[2] = t; + t = cp[4]; cp[4] = cp[3]; cp[3] = t; } #endif #ifndef TIFFSwabArrayOfDouble void -TIFFSwabArrayOfDouble(double* dp, register unsigned long n) +TIFFSwabArrayOfDouble(double* dp, tmsize_t n) { - register uint32* lp = (uint32*) dp; - register uint32 t; - - TIFFSwabArrayOfLong(lp, n + n); - while (n-- > 0) { - t = lp[0]; lp[0] = lp[1]; lp[1] = t; - lp += 2; - } + register unsigned char *cp; + register unsigned char t; + assert(sizeof(double)==8); + /* XXX unroll loop some */ + while (n-- > 0) { + cp = (unsigned char *)dp; + t = cp[7]; cp[7] = cp[0]; cp[0] = t; + t = cp[6]; cp[6] = cp[1]; cp[1] = t; + t = cp[5]; cp[5] = cp[2]; cp[2] = t; + t = cp[4]; cp[4] = cp[3]; cp[3] = t; + dp++; + } } #endif @@ -215,7 +283,7 @@ TIFFGetBitRevTable(int reversed) } void -TIFFReverseBits(register unsigned char* cp, register unsigned long n) +TIFFReverseBits(uint8* cp, tmsize_t n) { for (; n > 8; n -= 8) { cp[0] = TIFFBitRevTable[cp[0]]; @@ -233,3 +301,10 @@ TIFFReverseBits(register unsigned char* cp, register unsigned long n) } /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_thunder.c b/src/3rdparty/libtiff/libtiff/tif_thunder.c index 94496ec..390891c 100644 --- a/src/3rdparty/libtiff/libtiff/tif_thunder.c +++ b/src/3rdparty/libtiff/libtiff/tif_thunder.c @@ -1,4 +1,4 @@ -/* $Id: tif_thunder.c,v 1.5 2005/12/21 12:23:13 joris Exp $ */ +/* $Id: tif_thunder.c,v 1.12 2011-04-02 20:54:09 bfriesen Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler @@ -25,6 +25,7 @@ */ #include "tiffiop.h" +#include <assert.h> #ifdef THUNDER_SUPPORT /* * TIFF Library. @@ -55,21 +56,42 @@ static const int twobitdeltas[4] = { 0, 1, 0, -1 }; static const int threebitdeltas[8] = { 0, 1, 2, 3, 0, -3, -2, -1 }; -#define SETPIXEL(op, v) { \ - lastpixel = (v) & 0xf; \ - if (npixels++ & 1) \ - *op++ |= lastpixel; \ - else \ - op[0] = (tidataval_t) (lastpixel << 4); \ +#define SETPIXEL(op, v) { \ + lastpixel = (v) & 0xf; \ + if ( npixels < maxpixels ) \ + { \ + if (npixels++ & 1) \ + *op++ |= lastpixel; \ + else \ + op[0] = (uint8) (lastpixel << 4); \ + } \ } static int -ThunderDecode(TIFF* tif, tidata_t op, tsize_t maxpixels) +ThunderSetupDecode(TIFF* tif) { + static const char module[] = "ThunderSetupDecode"; + + if( tif->tif_dir.td_bitspersample != 4 ) + { + TIFFErrorExt(tif->tif_clientdata, module, + "Wrong bitspersample value (%d), Thunder decoder only supports 4bits per sample.", + (int) tif->tif_dir.td_bitspersample ); + return 0; + } + + + return (1); +} + +static int +ThunderDecode(TIFF* tif, uint8* op, tmsize_t maxpixels) +{ + static const char module[] = "ThunderDecode"; register unsigned char *bp; - register tsize_t cc; + register tmsize_t cc; unsigned int lastpixel; - tsize_t npixels; + tmsize_t npixels; bp = (unsigned char *)tif->tif_rawcp; cc = tif->tif_rawcc; @@ -93,7 +115,7 @@ ThunderDecode(TIFF* tif, tidata_t op, tsize_t maxpixels) npixels += n; if (npixels < maxpixels) { for (; n > 0; n -= 2) - *op++ = (tidataval_t) lastpixel; + *op++ = (uint8) lastpixel; } if (n == -1) *--op &= 0xf0; @@ -118,25 +140,43 @@ ThunderDecode(TIFF* tif, tidata_t op, tsize_t maxpixels) break; } } - tif->tif_rawcp = (tidata_t) bp; + tif->tif_rawcp = (uint8*) bp; tif->tif_rawcc = cc; if (npixels != maxpixels) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "ThunderDecode: %s data at scanline %ld (%lu != %lu)", - npixels < maxpixels ? "Not enough" : "Too much", - (long) tif->tif_row, (long) npixels, (long) maxpixels); +#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) + TIFFErrorExt(tif->tif_clientdata, module, + "%s data at scanline %lu (%I64u != %I64u)", + npixels < maxpixels ? "Not enough" : "Too much", + (unsigned long) tif->tif_row, + (unsigned __int64) npixels, + (unsigned __int64) maxpixels); +#else + TIFFErrorExt(tif->tif_clientdata, module, + "%s data at scanline %lu (%llu != %llu)", + npixels < maxpixels ? "Not enough" : "Too much", + (unsigned long) tif->tif_row, + (unsigned long long) npixels, + (unsigned long long) maxpixels); +#endif return (0); } - return (1); + + return (1); } static int -ThunderDecodeRow(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s) +ThunderDecodeRow(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s) { - tidata_t row = buf; + static const char module[] = "ThunderDecodeRow"; + uint8* row = buf; (void) s; - while ((long)occ > 0) { + if (occ % tif->tif_scanlinesize) + { + TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read"); + return (0); + } + while (occ > 0) { if (!ThunderDecode(tif, row, tif->tif_dir.td_imagewidth)) return (0); occ -= tif->tif_scanlinesize; @@ -149,10 +189,19 @@ int TIFFInitThunderScan(TIFF* tif, int scheme) { (void) scheme; + + tif->tif_setupdecode = ThunderSetupDecode; tif->tif_decoderow = ThunderDecodeRow; - tif->tif_decodestrip = ThunderDecodeRow; + tif->tif_decodestrip = ThunderDecodeRow; return (1); } #endif /* THUNDER_SUPPORT */ /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_tile.c b/src/3rdparty/libtiff/libtiff/tif_tile.c index 454fe5c..0ff7e85 100644 --- a/src/3rdparty/libtiff/libtiff/tif_tile.c +++ b/src/3rdparty/libtiff/libtiff/tif_tile.c @@ -1,4 +1,4 @@ -/* $Id: tif_tile.c,v 1.12 2006/02/09 16:15:43 dron Exp $ */ +/* $Id: tif_tile.c,v 1.23 2012-06-06 05:33:55 fwarmerdam Exp $ */ /* * Copyright (c) 1991-1997 Sam Leffler @@ -31,47 +31,17 @@ */ #include "tiffiop.h" -static uint32 -summarize(TIFF* tif, size_t summand1, size_t summand2, const char* where) -{ - /* - * XXX: We are using casting to uint32 here, because sizeof(size_t) - * may be larger than sizeof(uint32) on 64-bit architectures. - */ - uint32 bytes = summand1 + summand2; - - if (bytes - summand1 != summand2) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Integer overflow in %s", where); - bytes = 0; - } - - return (bytes); -} - -static uint32 -multiply(TIFF* tif, size_t nmemb, size_t elem_size, const char* where) -{ - uint32 bytes = nmemb * elem_size; - - if (elem_size && bytes / elem_size != nmemb) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Integer overflow in %s", where); - bytes = 0; - } - - return (bytes); -} - /* * Compute which tile an (x,y,z,s) value is in. */ -ttile_t -TIFFComputeTile(TIFF* tif, uint32 x, uint32 y, uint32 z, tsample_t s) +uint32 +TIFFComputeTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s) { TIFFDirectory *td = &tif->tif_dir; uint32 dx = td->td_tilewidth; uint32 dy = td->td_tilelength; uint32 dz = td->td_tiledepth; - ttile_t tile = 1; + uint32 tile = 1; if (td->td_imagedepth == 1) z = 0; @@ -82,9 +52,9 @@ TIFFComputeTile(TIFF* tif, uint32 x, uint32 y, uint32 z, tsample_t s) if (dz == (uint32) -1) dz = td->td_imagedepth; if (dx != 0 && dy != 0 && dz != 0) { - uint32 xpt = TIFFhowmany(td->td_imagewidth, dx); - uint32 ypt = TIFFhowmany(td->td_imagelength, dy); - uint32 zpt = TIFFhowmany(td->td_imagedepth, dz); + uint32 xpt = TIFFhowmany_32(td->td_imagewidth, dx); + uint32 ypt = TIFFhowmany_32(td->td_imagelength, dy); + uint32 zpt = TIFFhowmany_32(td->td_imagedepth, dz); if (td->td_planarconfig == PLANARCONFIG_SEPARATE) tile = (xpt*ypt*zpt)*s + @@ -102,7 +72,7 @@ TIFFComputeTile(TIFF* tif, uint32 x, uint32 y, uint32 z, tsample_t s) * against the image bounds. */ int -TIFFCheckTile(TIFF* tif, uint32 x, uint32 y, uint32 z, tsample_t s) +TIFFCheckTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s) { TIFFDirectory *td = &tif->tif_dir; @@ -141,14 +111,14 @@ TIFFCheckTile(TIFF* tif, uint32 x, uint32 y, uint32 z, tsample_t s) /* * Compute how many tiles are in an image. */ -ttile_t +uint32 TIFFNumberOfTiles(TIFF* tif) { TIFFDirectory *td = &tif->tif_dir; uint32 dx = td->td_tilewidth; uint32 dy = td->td_tilelength; uint32 dz = td->td_tiledepth; - ttile_t ntiles; + uint32 ntiles; if (dx == (uint32) -1) dx = td->td_imagewidth; @@ -157,50 +127,66 @@ TIFFNumberOfTiles(TIFF* tif) if (dz == (uint32) -1) dz = td->td_imagedepth; ntiles = (dx == 0 || dy == 0 || dz == 0) ? 0 : - multiply(tif, multiply(tif, TIFFhowmany(td->td_imagewidth, dx), - TIFFhowmany(td->td_imagelength, dy), - "TIFFNumberOfTiles"), - TIFFhowmany(td->td_imagedepth, dz), "TIFFNumberOfTiles"); + _TIFFMultiply32(tif, _TIFFMultiply32(tif, TIFFhowmany_32(td->td_imagewidth, dx), + TIFFhowmany_32(td->td_imagelength, dy), + "TIFFNumberOfTiles"), + TIFFhowmany_32(td->td_imagedepth, dz), "TIFFNumberOfTiles"); if (td->td_planarconfig == PLANARCONFIG_SEPARATE) - ntiles = multiply(tif, ntiles, td->td_samplesperpixel, - "TIFFNumberOfTiles"); + ntiles = _TIFFMultiply32(tif, ntiles, td->td_samplesperpixel, + "TIFFNumberOfTiles"); return (ntiles); } /* * Compute the # bytes in each row of a tile. */ -tsize_t -TIFFTileRowSize(TIFF* tif) +uint64 +TIFFTileRowSize64(TIFF* tif) { TIFFDirectory *td = &tif->tif_dir; - tsize_t rowsize; - + uint64 rowsize; + if (td->td_tilelength == 0 || td->td_tilewidth == 0) - return ((tsize_t) 0); - rowsize = multiply(tif, td->td_bitspersample, td->td_tilewidth, - "TIFFTileRowSize"); + return (0); + rowsize = _TIFFMultiply64(tif, td->td_bitspersample, td->td_tilewidth, + "TIFFTileRowSize"); if (td->td_planarconfig == PLANARCONFIG_CONTIG) - rowsize = multiply(tif, rowsize, td->td_samplesperpixel, - "TIFFTileRowSize"); - return ((tsize_t) TIFFhowmany8(rowsize)); + rowsize = _TIFFMultiply64(tif, rowsize, td->td_samplesperpixel, + "TIFFTileRowSize"); + return (TIFFhowmany8_64(rowsize)); +} +tmsize_t +TIFFTileRowSize(TIFF* tif) +{ + static const char module[] = "TIFFTileRowSize"; + uint64 m; + tmsize_t n; + m=TIFFTileRowSize64(tif); + n=(tmsize_t)m; + if ((uint64)n!=m) + { + TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow"); + n=0; + } + return(n); } /* * Compute the # bytes in a variable length, row-aligned tile. */ -tsize_t -TIFFVTileSize(TIFF* tif, uint32 nrows) +uint64 +TIFFVTileSize64(TIFF* tif, uint32 nrows) { + static const char module[] = "TIFFVTileSize64"; TIFFDirectory *td = &tif->tif_dir; - tsize_t tilesize; - if (td->td_tilelength == 0 || td->td_tilewidth == 0 || td->td_tiledepth == 0) - return ((tsize_t) 0); - if (td->td_planarconfig == PLANARCONFIG_CONTIG && - td->td_photometric == PHOTOMETRIC_YCBCR && - !isUpSampled(tif)) { + return (0); + if ((td->td_planarconfig==PLANARCONFIG_CONTIG)&& + (td->td_photometric==PHOTOMETRIC_YCBCR)&& + (td->td_samplesperpixel==3)&& + (!isUpSampled(tif))) + { /* * Packed YCbCr data contain one Cb+Cr for every * HorizontalSampling*VerticalSampling Y values. @@ -209,38 +195,71 @@ TIFFVTileSize(TIFF* tif, uint32 nrows) * horizontal/vertical subsampling area include * YCbCr data for the extended image. */ - tsize_t w = - TIFFroundup(td->td_tilewidth, td->td_ycbcrsubsampling[0]); - tsize_t rowsize = - TIFFhowmany8(multiply(tif, w, td->td_bitspersample, - "TIFFVTileSize")); - tsize_t samplingarea = - td->td_ycbcrsubsampling[0]*td->td_ycbcrsubsampling[1]; - if (samplingarea == 0) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Invalid YCbCr subsampling"); + uint16 ycbcrsubsampling[2]; + uint16 samplingblock_samples; + uint32 samplingblocks_hor; + uint32 samplingblocks_ver; + uint64 samplingrow_samples; + uint64 samplingrow_size; + TIFFGetFieldDefaulted(tif,TIFFTAG_YCBCRSUBSAMPLING,ycbcrsubsampling+0, + ycbcrsubsampling+1); + if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 && ycbcrsubsampling[0] != 4) + ||(ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 && ycbcrsubsampling[1] != 4)) + { + TIFFErrorExt(tif->tif_clientdata,module, + "Invalid YCbCr subsampling (%dx%d)", + ycbcrsubsampling[0], + ycbcrsubsampling[1] ); return 0; } - nrows = TIFFroundup(nrows, td->td_ycbcrsubsampling[1]); - /* NB: don't need TIFFhowmany here 'cuz everything is rounded */ - tilesize = multiply(tif, nrows, rowsize, "TIFFVTileSize"); - tilesize = summarize(tif, tilesize, - multiply(tif, 2, tilesize / samplingarea, - "TIFFVTileSize"), - "TIFFVTileSize"); - } else - tilesize = multiply(tif, nrows, TIFFTileRowSize(tif), - "TIFFVTileSize"); - return ((tsize_t) - multiply(tif, tilesize, td->td_tiledepth, "TIFFVTileSize")); + samplingblock_samples=ycbcrsubsampling[0]*ycbcrsubsampling[1]+2; + samplingblocks_hor=TIFFhowmany_32(td->td_tilewidth,ycbcrsubsampling[0]); + samplingblocks_ver=TIFFhowmany_32(nrows,ycbcrsubsampling[1]); + samplingrow_samples=_TIFFMultiply64(tif,samplingblocks_hor,samplingblock_samples,module); + samplingrow_size=TIFFhowmany8_64(_TIFFMultiply64(tif,samplingrow_samples,td->td_bitspersample,module)); + return(_TIFFMultiply64(tif,samplingrow_size,samplingblocks_ver,module)); + } + else + return(_TIFFMultiply64(tif,nrows,TIFFTileRowSize64(tif),module)); +} +tmsize_t +TIFFVTileSize(TIFF* tif, uint32 nrows) +{ + static const char module[] = "TIFFVTileSize"; + uint64 m; + tmsize_t n; + m=TIFFVTileSize64(tif,nrows); + n=(tmsize_t)m; + if ((uint64)n!=m) + { + TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow"); + n=0; + } + return(n); } /* * Compute the # bytes in a row-aligned tile. */ -tsize_t +uint64 +TIFFTileSize64(TIFF* tif) +{ + return (TIFFVTileSize64(tif, tif->tif_dir.td_tilelength)); +} +tmsize_t TIFFTileSize(TIFF* tif) { - return (TIFFVTileSize(tif, tif->tif_dir.td_tilelength)); + static const char module[] = "TIFFTileSize"; + uint64 m; + tmsize_t n; + m=TIFFTileSize64(tif); + n=(tmsize_t)m; + if ((uint64)n!=m) + { + TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow"); + n=0; + } + return(n); } /* @@ -265,9 +284,16 @@ _TIFFDefaultTileSize(TIFF* tif, uint32* tw, uint32* th) *th = 256; /* roundup to a multiple of 16 per the spec */ if (*tw & 0xf) - *tw = TIFFroundup(*tw, 16); + *tw = TIFFroundup_32(*tw, 16); if (*th & 0xf) - *th = TIFFroundup(*th, 16); + *th = TIFFroundup_32(*th, 16); } /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_unix.c b/src/3rdparty/libtiff/libtiff/tif_unix.c index 2c3bf7d..1387558 100644 --- a/src/3rdparty/libtiff/libtiff/tif_unix.c +++ b/src/3rdparty/libtiff/libtiff/tif_unix.c @@ -1,26 +1,26 @@ -/* $Id: tif_unix.c,v 1.12 2006/03/21 16:37:51 dron Exp $ */ +/* $Id: tif_unix.c,v 1.23 2012-06-01 21:40:59 fwarmerdam Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * - * Permission to use, copy, modify, distribute, and sell this software and + * 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. - * + * + * 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 + * 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. */ @@ -28,12 +28,15 @@ * TIFF Library UNIX-specific Routines. These are should also work with the * Windows Common RunTime Library. */ + #include "tif_config.h" #ifdef HAVE_SYS_TYPES_H # include <sys/types.h> #endif +#include <errno.h> + #include <stdarg.h> #include <stdlib.h> #include <sys/stat.h> @@ -52,55 +55,71 @@ #include "tiffiop.h" -static tsize_t -_tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size) +static tmsize_t +_tiffReadProc(thandle_t fd, void* buf, tmsize_t size) { - return ((tsize_t) read((int) fd, buf, (size_t) size)); + size_t size_io = (size_t) size; + if ((tmsize_t) size_io != size) + { + errno=EINVAL; + return (tmsize_t) -1; + } + return ((tmsize_t) read((int) fd, buf, size_io)); } -static tsize_t -_tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size) +static tmsize_t +_tiffWriteProc(thandle_t fd, void* buf, tmsize_t size) { - return ((tsize_t) write((int) fd, buf, (size_t) size)); + size_t size_io = (size_t) size; + if ((tmsize_t) size_io != size) + { + errno=EINVAL; + return (tmsize_t) -1; + } + return ((tmsize_t) write((int) fd, buf, size_io)); } -static toff_t -_tiffSeekProc(thandle_t fd, toff_t off, int whence) +static uint64 +_tiffSeekProc(thandle_t fd, uint64 off, int whence) { - return ((toff_t) lseek((int) fd, (off_t) off, whence)); + off_t off_io = (off_t) off; + if ((uint64) off_io != off) + { + errno=EINVAL; + return (uint64) -1; /* this is really gross */ + } + return((uint64)lseek((int)fd,off_io,whence)); } static int _tiffCloseProc(thandle_t fd) { - return (close((int) fd)); + return(close((int)fd)); } - -static toff_t +static uint64 _tiffSizeProc(thandle_t fd) { -#ifdef _AM29K - long fsize; - return ((fsize = lseek((int) fd, 0, SEEK_END)) < 0 ? 0 : fsize); -#else struct stat sb; - return (toff_t) (fstat((int) fd, &sb) < 0 ? 0 : sb.st_size); -#endif + if (fstat((int)fd,&sb)<0) + return(0); + else + return((uint64)sb.st_size); } #ifdef HAVE_MMAP #include <sys/mman.h> static int -_tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) +_tiffMapProc(thandle_t fd, void** pbase, toff_t* psize) { - toff_t size = _tiffSizeProc(fd); - if (size != (toff_t) -1) { - *pbase = (tdata_t) - mmap(0, size, PROT_READ, MAP_SHARED, (int) fd, 0); - if (*pbase != (tdata_t) -1) { - *psize = size; + uint64 size64 = _tiffSizeProc(fd); + tmsize_t sizem = (tmsize_t)size64; + if ((uint64)sizem==size64) { + *pbase = (void*) + mmap(0, (size_t)sizem, PROT_READ, MAP_SHARED, (int) fd, 0); + if (*pbase != (void*) -1) { + *psize = (tmsize_t)sizem; return (1); } } @@ -108,21 +127,21 @@ _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) } static void -_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size) +_tiffUnmapProc(thandle_t fd, void* base, toff_t size) { (void) fd; (void) munmap(base, (off_t) size); } #else /* !HAVE_MMAP */ static int -_tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) +_tiffMapProc(thandle_t fd, void** pbase, toff_t* psize) { (void) fd; (void) pbase; (void) psize; return (0); } static void -_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size) +_tiffUnmapProc(thandle_t fd, void* base, toff_t size) { (void) fd; (void) base; (void) size; } @@ -154,24 +173,24 @@ TIFFOpen(const char* name, const char* mode) { static const char module[] = "TIFFOpen"; int m, fd; - TIFF* tif; + TIFF* tif; m = _TIFFgetMode(mode, module); if (m == -1) return ((TIFF*)0); -/* for cygwin and mingw */ +/* for cygwin and mingw */ #ifdef O_BINARY - m |= O_BINARY; -#endif - -#ifdef _AM29K - fd = open(name, m); -#else - fd = open(name, m, 0666); + m |= O_BINARY; #endif + + fd = open(name, m, 0666); if (fd < 0) { - TIFFErrorExt(0, module, "%s: Cannot open", name); + if (errno > 0 && strerror(errno) != NULL ) { + TIFFErrorExt(0, module, "%s: %s", name, strerror(errno) ); + } else { + TIFFErrorExt(0, module, "%s: Cannot open", name); + } return ((TIFF *)0); } @@ -181,7 +200,7 @@ TIFFOpen(const char* name, const char* mode) return tif; } -#if defined (__WIN32__) && !defined(__SYMBIAN32__) +#ifdef __WIN32__ #include <windows.h> /* * Open a TIFF file with a Unicode filename, for read/writing. @@ -199,11 +218,11 @@ TIFFOpenW(const wchar_t* name, const char* mode) if (m == -1) return ((TIFF*)0); -/* for cygwin and mingw */ +/* for cygwin and mingw */ #ifdef O_BINARY - m |= O_BINARY; -#endif - + m |= O_BINARY; +#endif + fd = _wopen(name, m, 0666); if (fd < 0) { TIFFErrorExt(0, module, "%s: Cannot open", name); @@ -236,37 +255,37 @@ TIFFOpenW(const wchar_t* name, const char* mode) #endif void* -_TIFFmalloc(tsize_t s) +_TIFFmalloc(tmsize_t s) { return (malloc((size_t) s)); } void -_TIFFfree(tdata_t p) +_TIFFfree(void* p) { free(p); } void* -_TIFFrealloc(tdata_t p, tsize_t s) +_TIFFrealloc(void* p, tmsize_t s) { return (realloc(p, (size_t) s)); } void -_TIFFmemset(tdata_t p, int v, tsize_t c) +_TIFFmemset(void* p, int v, tmsize_t c) { memset(p, v, (size_t) c); } void -_TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c) +_TIFFmemcpy(void* d, const void* s, tmsize_t c) { memcpy(d, s, (size_t) c); } int -_TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c) +_TIFFmemcmp(const void* p1, const void* p2, tmsize_t c) { return (memcmp(p1, p2, (size_t) c)); } @@ -291,3 +310,13 @@ unixErrorHandler(const char* module, const char* fmt, va_list ap) fprintf(stderr, ".\n"); } TIFFErrorHandler _TIFFerrorHandler = unixErrorHandler; + +/* vim: set ts=8 sts=8 sw=8 noet: */ + +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_version.c b/src/3rdparty/libtiff/libtiff/tif_version.c index 1264b71..f92c843 100644 --- a/src/3rdparty/libtiff/libtiff/tif_version.c +++ b/src/3rdparty/libtiff/libtiff/tif_version.c @@ -1,4 +1,4 @@ -/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_version.c,v 1.2 2000/11/13 14:42:38 warmerda Exp $ */ +/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_version.c,v 1.3 2010-03-10 18:56:49 bfriesen Exp $ */ /* * Copyright (c) 1992-1997 Sam Leffler * Copyright (c) 1992-1997 Silicon Graphics, Inc. @@ -31,3 +31,10 @@ TIFFGetVersion(void) { return (TIFFVersion); } +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_warning.c b/src/3rdparty/libtiff/libtiff/tif_warning.c index d593469..423b636 100644 --- a/src/3rdparty/libtiff/libtiff/tif_warning.c +++ b/src/3rdparty/libtiff/libtiff/tif_warning.c @@ -1,4 +1,4 @@ -/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_warning.c,v 1.2 2005/12/23 01:18:59 joris Exp $ */ +/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_warning.c,v 1.3 2010-03-10 18:56:49 bfriesen Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler @@ -72,3 +72,10 @@ TIFFWarningExt(thandle_t fd, const char* module, const char* fmt, ...) } +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_win3.c b/src/3rdparty/libtiff/libtiff/tif_win3.c deleted file mode 100644 index b16b214..0000000 --- a/src/3rdparty/libtiff/libtiff/tif_win3.c +++ /dev/null @@ -1,225 +0,0 @@ -/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_win3.c,v 1.2 2005/12/21 12:23:13 joris Exp $ */ - -/* - * Copyright (c) 1988-1997 Sam Leffler - * Copyright (c) 1991-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. - */ - -/* - * TIFF Library Windows 3.x-specific Routines. - */ -#include "tiffiop.h" -#if defined(__WATCOMC__) || defined(__BORLANDC__) || defined(_MSC_VER) -#include <io.h> /* for open, close, etc. function prototypes */ -#endif - -#include <windows.h> -#include <windowsx.h> -#include <memory.h> - -static tsize_t -_tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size) -{ - return (_hread(fd, buf, size)); -} - -static tsize_t -_tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size) -{ - return (_hwrite(fd, buf, size)); -} - -static toff_t -_tiffSeekProc(thandle_t fd, toff_t off, int whence) -{ - return (_llseek(fd, (off_t) off, whence)); -} - -static int -_tiffCloseProc(thandle_t fd) -{ - return (_lclose(fd)); -} - -#include <sys/stat.h> - -static toff_t -_tiffSizeProc(thandle_t fd) -{ - struct stat sb; - return (fstat((int) fd, &sb) < 0 ? 0 : sb.st_size); -} - -static int -_tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) -{ - return (0); -} - -static void -_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size) -{ -} - -/* - * Open a TIFF file descriptor for read/writing. - */ -TIFF* -TIFFFdOpen(int fd, const char* name, const char* mode) -{ - TIFF* tif; - - tif = TIFFClientOpen(name, mode, - (thandle_t) fd, - _tiffReadProc, _tiffWriteProc, _tiffSeekProc, _tiffCloseProc, - _tiffSizeProc, _tiffMapProc, _tiffUnmapProc); - if (tif) - tif->tif_fd = fd; - return (tif); -} - -/* - * Open a TIFF file for read/writing. - */ -TIFF* -TIFFOpen(const char* name, const char* mode) -{ - static const char module[] = "TIFFOpen"; - int m, fd; - OFSTRUCT of; - int mm = 0; - - m = _TIFFgetMode(mode, module); - if (m == -1) - return ((TIFF*)0); - if (m & O_CREAT) { - if ((m & O_TRUNC) || OpenFile(name, &of, OF_EXIST) != HFILE_ERROR) - mm |= OF_CREATE; - } - if (m & O_WRONLY) - mm |= OF_WRITE; - if (m & O_RDWR) - mm |= OF_READWRITE; - fd = OpenFile(name, &of, mm); - if (fd < 0) { - TIFFErrorExt(0, module, "%s: Cannot open", name); - return ((TIFF*)0); - } - return (TIFFFdOpen(fd, name, mode)); -} - -tdata_t -_TIFFmalloc(tsize_t s) -{ - return (tdata_t) GlobalAllocPtr(GHND, (DWORD) s); -} - -void -_TIFFfree(tdata_t p) -{ - GlobalFreePtr(p); -} - -tdata_t -_TIFFrealloc(tdata_t p, tsize_t s) -{ - return (tdata_t) GlobalReAllocPtr(p, (DWORD) s, GHND); -} - -void -_TIFFmemset(tdata_t p, int v, tsize_t c) -{ - char* pp = (char*) p; - - while (c > 0) { - tsize_t chunk = 0x10000 - ((uint32) pp & 0xffff);/* What's left in segment */ - if (chunk > 0xff00) /* No more than 0xff00 */ - chunk = 0xff00; - if (chunk > c) /* No more than needed */ - chunk = c; - memset(pp, v, chunk); - pp = (char*) (chunk + (char huge*) pp); - c -= chunk; - } -} - -void -_TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c) -{ - if (c > 0xFFFF) - hmemcpy((void _huge*) d, (void _huge*) s, c); - else - (void) memcpy(d, s, (size_t) c); -} - -int -_TIFFmemcmp(const tdata_t d, const tdata_t s, tsize_t c) -{ - char* dd = (char*) d; - char* ss = (char*) s; - tsize_t chunks, chunkd, chunk; - int result; - - while (c > 0) { - chunks = 0x10000 - ((uint32) ss & 0xffff); /* What's left in segment */ - chunkd = 0x10000 - ((uint32) dd & 0xffff); /* What's left in segment */ - chunk = c; /* Get the largest of */ - if (chunk > chunks) /* c, chunks, chunkd, */ - chunk = chunks; /* 0xff00 */ - if (chunk > chunkd) - chunk = chunkd; - if (chunk > 0xff00) - chunk = 0xff00; - result = memcmp(dd, ss, chunk); - if (result != 0) - return (result); - dd = (char*) (chunk + (char huge*) dd); - ss = (char*) (chunk + (char huge*) ss); - c -= chunk; - } - return (0); -} - -static void -win3WarningHandler(const char* module, const char* fmt, va_list ap) -{ - char e[512] = { '\0' }; - if (module != NULL) - strcat(strcpy(e, module), ":"); - vsprintf(e+strlen(e), fmt, ap); - strcat(e, "."); - MessageBox(GetActiveWindow(), e, "LibTIFF Warning", - MB_OK|MB_ICONEXCLAMATION); -} -TIFFErrorHandler _TIFFwarningHandler = win3WarningHandler; - -static void -win3ErrorHandler(const char* module, const char* fmt, va_list ap) -{ - char e[512] = { '\0' }; - if (module != NULL) - strcat(strcpy(e, module), ":"); - vsprintf(e+strlen(e), fmt, ap); - strcat(e, "."); - MessageBox(GetActiveWindow(), e, "LibTIFF Error", MB_OK|MB_ICONSTOP); -} -TIFFErrorHandler _TIFFerrorHandler = win3ErrorHandler; diff --git a/src/3rdparty/libtiff/libtiff/tif_win32.c b/src/3rdparty/libtiff/libtiff/tif_win32.c index d7f33de..5fa828f 100644 --- a/src/3rdparty/libtiff/libtiff/tif_win32.c +++ b/src/3rdparty/libtiff/libtiff/tif_win32.c @@ -1,4 +1,4 @@ -/* $Id: tif_win32.c,v 1.21 2007/03/07 17:10:31 joris Exp $ */ +/* $Id: tif_win32.c,v 1.39 2011-12-22 17:07:57 bfriesen Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler @@ -29,53 +29,94 @@ * Scott Wagner (wagner@itek.com), Itek Graphix, Rochester, NY USA */ #include "tiffiop.h" -#include <windows.h> #include <windows.h> -static tsize_t -_tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size) +static tmsize_t +_tiffReadProc(thandle_t fd, void* buf, tmsize_t size) { - DWORD dwSizeRead; - if (!ReadFile(fd, buf, size, &dwSizeRead, NULL)) - return(0); - return ((tsize_t) dwSizeRead); + /* tmsize_t is 64bit on 64bit systems, but the WinAPI ReadFile takes + * 32bit sizes, so we loop through the data in suitable 32bit sized + * chunks */ + uint8* ma; + uint64 mb; + DWORD n; + DWORD o; + tmsize_t p; + ma=(uint8*)buf; + mb=size; + p=0; + while (mb>0) + { + n=0x80000000UL; + if ((uint64)n>mb) + n=(DWORD)mb; + if (!ReadFile(fd,(LPVOID)ma,n,&o,NULL)) + return(0); + ma+=o; + mb-=o; + p+=o; + if (o!=n) + break; + } + return(p); } -static tsize_t -_tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size) +static tmsize_t +_tiffWriteProc(thandle_t fd, void* buf, tmsize_t size) { - DWORD dwSizeWritten; - if (!WriteFile(fd, buf, size, &dwSizeWritten, NULL)) - return(0); - return ((tsize_t) dwSizeWritten); + /* tmsize_t is 64bit on 64bit systems, but the WinAPI WriteFile takes + * 32bit sizes, so we loop through the data in suitable 32bit sized + * chunks */ + uint8* ma; + uint64 mb; + DWORD n; + DWORD o; + tmsize_t p; + ma=(uint8*)buf; + mb=size; + p=0; + while (mb>0) + { + n=0x80000000UL; + if ((uint64)n>mb) + n=(DWORD)mb; + if (!WriteFile(fd,(LPVOID)ma,n,&o,NULL)) + return(0); + ma+=o; + mb-=o; + p+=o; + if (o!=n) + break; + } + return(p); } -static toff_t -_tiffSeekProc(thandle_t fd, toff_t off, int whence) +static uint64 +_tiffSeekProc(thandle_t fd, uint64 off, int whence) { - ULARGE_INTEGER li; + LARGE_INTEGER offli; DWORD dwMoveMethod; - - li.QuadPart = off; - + offli.QuadPart = off; switch(whence) { - case SEEK_SET: - dwMoveMethod = FILE_BEGIN; - break; - case SEEK_CUR: - dwMoveMethod = FILE_CURRENT; - break; - case SEEK_END: - dwMoveMethod = FILE_END; - break; - default: - dwMoveMethod = FILE_BEGIN; - break; + case SEEK_SET: + dwMoveMethod = FILE_BEGIN; + break; + case SEEK_CUR: + dwMoveMethod = FILE_CURRENT; + break; + case SEEK_END: + dwMoveMethod = FILE_END; + break; + default: + dwMoveMethod = FILE_BEGIN; + break; } - return ((toff_t)SetFilePointer(fd, (LONG) li.LowPart, - (PLONG)&li.HighPart, dwMoveMethod)); + offli.LowPart=SetFilePointer(fd,offli.LowPart,&offli.HighPart,dwMoveMethod); + if ((offli.LowPart==INVALID_SET_FILE_POINTER)&&(GetLastError()!=NO_ERROR)) + offli.QuadPart=0; + return(offli.QuadPart); } static int @@ -84,14 +125,16 @@ _tiffCloseProc(thandle_t fd) return (CloseHandle(fd) ? 0 : -1); } -static toff_t +static uint64 _tiffSizeProc(thandle_t fd) { - return ((toff_t)GetFileSize(fd, NULL)); + ULARGE_INTEGER m; + m.LowPart=GetFileSize(fd,&m.HighPart); + return(m.QuadPart); } static int -_tiffDummyMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) +_tiffDummyMapProc(thandle_t fd, void** pbase, toff_t* psize) { (void) fd; (void) pbase; @@ -111,14 +154,20 @@ _tiffDummyMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) * with Visual C++ 5.0 */ static int -_tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) +_tiffMapProc(thandle_t fd, void** pbase, toff_t* psize) { - toff_t size; + uint64 size; + tmsize_t sizem; HANDLE hMapFile; - if ((size = _tiffSizeProc(fd)) == 0xFFFFFFFF) + size = _tiffSizeProc(fd); + sizem = (tmsize_t)size; + if ((uint64)sizem!=size) return (0); - hMapFile = CreateFileMapping(fd, NULL, PAGE_READONLY, 0, size, NULL); + + /* By passing in 0 for the maximum file size, it specifies that we + create a file mapping object for the full file size. */ + hMapFile = CreateFileMapping(fd, NULL, PAGE_READONLY, 0, 0, NULL); if (hMapFile == NULL) return (0); *pbase = MapViewOfFile(hMapFile, FILE_MAP_READ, 0, 0, 0); @@ -130,7 +179,7 @@ _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) } static void -_tiffDummyUnmapProc(thandle_t fd, tdata_t base, toff_t size) +_tiffDummyUnmapProc(thandle_t fd, void* base, toff_t size) { (void) fd; (void) base; @@ -138,8 +187,10 @@ _tiffDummyUnmapProc(thandle_t fd, tdata_t base, toff_t size) } static void -_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size) +_tiffUnmapProc(thandle_t fd, void* base, toff_t size) { + (void) fd; + (void) size; UnmapViewOfFile(base); } @@ -152,8 +203,17 @@ TIFF* TIFFFdOpen(int ifd, const char* name, const char* mode) { TIFF* tif; - BOOL fSuppressMap = (mode[1] == 'u' || (mode[1]!=0 && mode[2] == 'u')); - + int fSuppressMap; + int m; + fSuppressMap=0; + for (m=0; mode[m]!=0; m++) + { + if (mode[m]=='u') + { + fSuppressMap=1; + break; + } + } tif = TIFFClientOpen(name, mode, (thandle_t)ifd, _tiffReadProc, _tiffWriteProc, _tiffSeekProc, _tiffCloseProc, _tiffSizeProc, @@ -180,26 +240,15 @@ TIFFOpen(const char* name, const char* mode) m = _TIFFgetMode(mode, module); - switch(m) - { - case O_RDONLY: - dwMode = OPEN_EXISTING; - break; - case O_RDWR: - dwMode = OPEN_ALWAYS; - break; - case O_RDWR|O_CREAT: - dwMode = OPEN_ALWAYS; - break; - case O_RDWR|O_TRUNC: - dwMode = CREATE_ALWAYS; - break; - case O_RDWR|O_CREAT|O_TRUNC: - dwMode = CREATE_ALWAYS; - break; - default: - return ((TIFF*)0); + switch(m) { + case O_RDONLY: dwMode = OPEN_EXISTING; break; + case O_RDWR: dwMode = OPEN_ALWAYS; break; + case O_RDWR|O_CREAT: dwMode = OPEN_ALWAYS; break; + case O_RDWR|O_TRUNC: dwMode = CREATE_ALWAYS; break; + case O_RDWR|O_CREAT|O_TRUNC: dwMode = CREATE_ALWAYS; break; + default: return ((TIFF*)0); } + fd = (thandle_t)CreateFileA(name, (m == O_RDONLY)?GENERIC_READ:(GENERIC_READ | GENERIC_WRITE), FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, dwMode, @@ -243,7 +292,7 @@ TIFFOpenW(const wchar_t* name, const char* mode) fd = (thandle_t)CreateFileW(name, (m == O_RDONLY)?GENERIC_READ:(GENERIC_READ|GENERIC_WRITE), - FILE_SHARE_READ, NULL, dwMode, + FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, dwMode, (m == O_RDONLY)?FILE_ATTRIBUTE_READONLY:FILE_ATTRIBUTE_NORMAL, NULL); if (fd == INVALID_HANDLE_VALUE) { @@ -277,70 +326,46 @@ TIFFOpenW(const wchar_t* name, const char* mode) #endif /* ndef _WIN32_WCE */ - -tdata_t -_TIFFmalloc(tsize_t s) +void* +_TIFFmalloc(tmsize_t s) { - return ((tdata_t)GlobalAlloc(GMEM_FIXED, s)); + return (malloc((size_t) s)); } void -_TIFFfree(tdata_t p) +_TIFFfree(void* p) { - GlobalFree(p); - return; + free(p); } -tdata_t -_TIFFrealloc(tdata_t p, tsize_t s) +void* +_TIFFrealloc(void* p, tmsize_t s) { - void* pvTmp; - tsize_t old; - - if(p == NULL) - return ((tdata_t)GlobalAlloc(GMEM_FIXED, s)); - - old = GlobalSize(p); - - if (old>=s) { - if ((pvTmp = GlobalAlloc(GMEM_FIXED, s)) != NULL) { - CopyMemory(pvTmp, p, s); - GlobalFree(p); - } - } else { - if ((pvTmp = GlobalAlloc(GMEM_FIXED, s)) != NULL) { - CopyMemory(pvTmp, p, old); - GlobalFree(p); - } - } - return ((tdata_t)pvTmp); + return (realloc(p, (size_t) s)); } void -_TIFFmemset(void* p, int v, tsize_t c) +_TIFFmemset(void* p, int v, tmsize_t c) { - FillMemory(p, c, (BYTE)v); + memset(p, v, (size_t) c); } void -_TIFFmemcpy(void* d, const tdata_t s, tsize_t c) +_TIFFmemcpy(void* d, const void* s, tmsize_t c) { - CopyMemory(d, s, c); + memcpy(d, s, (size_t) c); } int -_TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c) +_TIFFmemcmp(const void* p1, const void* p2, tmsize_t c) { - register const BYTE *pb1 = (const BYTE *) p1; - register const BYTE *pb2 = (const BYTE *) p2; - register DWORD dwTmp = c; - register int iTmp; - for (iTmp = 0; dwTmp-- && !iTmp; iTmp = (int)*pb1++ - (int)*pb2++) - ; - return (iTmp); + return (memcmp(p1, p2, (size_t) c)); } -#ifndef _WIN32_WCE + +#if (_MSC_VER < 1500) +# define vsnprintf _vsnprintf +#endif static void Win32WarningHandler(const char* module, const char* fmt, va_list ap) @@ -351,14 +376,17 @@ Win32WarningHandler(const char* module, const char* fmt, va_list ap) LPCTSTR szTitleText = "%s Warning"; LPCTSTR szDefaultModule = "LIBTIFF"; LPCTSTR szTmpModule = (module == NULL) ? szDefaultModule : module; - if ((szTitle = (LPTSTR)LocalAlloc(LMEM_FIXED, (strlen(szTmpModule) + - strlen(szTitleText) + strlen(fmt) + 128)*sizeof(char))) == NULL) + SIZE_T nBufSize = (strlen(szTmpModule) + + strlen(szTitleText) + strlen(fmt) + 256)*sizeof(char); + + if ((szTitle = (LPTSTR)LocalAlloc(LMEM_FIXED, nBufSize)) == NULL) return; sprintf(szTitle, szTitleText, szTmpModule); szTmp = szTitle + (strlen(szTitle)+2)*sizeof(char); - vsprintf(szTmp, fmt, ap); + vsnprintf(szTmp, nBufSize-(strlen(szTitle)+2)*sizeof(char), fmt, ap); MessageBoxA(GetFocus(), szTmp, szTitle, MB_OK | MB_ICONINFORMATION); LocalFree(szTitle); + return; #else if (module != NULL) @@ -379,12 +407,14 @@ Win32ErrorHandler(const char* module, const char* fmt, va_list ap) LPCTSTR szTitleText = "%s Error"; LPCTSTR szDefaultModule = "LIBTIFF"; LPCTSTR szTmpModule = (module == NULL) ? szDefaultModule : module; - if ((szTitle = (LPTSTR)LocalAlloc(LMEM_FIXED, (strlen(szTmpModule) + - strlen(szTitleText) + strlen(fmt) + 128)*sizeof(char))) == NULL) + SIZE_T nBufSize = (strlen(szTmpModule) + + strlen(szTitleText) + strlen(fmt) + 256)*sizeof(char); + + if ((szTitle = (LPTSTR)LocalAlloc(LMEM_FIXED, nBufSize)) == NULL) return; sprintf(szTitle, szTitleText, szTmpModule); szTmp = szTitle + (strlen(szTitle)+2)*sizeof(char); - vsprintf(szTmp, fmt, ap); + vsnprintf(szTmp, nBufSize-(strlen(szTitle)+2)*sizeof(char), fmt, ap); MessageBoxA(GetFocus(), szTmp, szTitle, MB_OK | MB_ICONEXCLAMATION); LocalFree(szTitle); return; @@ -397,6 +427,12 @@ Win32ErrorHandler(const char* module, const char* fmt, va_list ap) } TIFFErrorHandler _TIFFerrorHandler = Win32ErrorHandler; -#endif /* ndef _WIN32_WCE */ /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_wince.c b/src/3rdparty/libtiff/libtiff/tif_wince.c deleted file mode 100644 index 4e283da..0000000 --- a/src/3rdparty/libtiff/libtiff/tif_wince.c +++ /dev/null @@ -1,281 +0,0 @@ -/* $Id: tif_wince.c,v 1.1 2007-01-15 18:40:39 mloskot Exp $ */ - -/* - * Copyright (c) 1988-1997 Sam Leffler - * Copyright (c) 1991-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. - */ - -/* - * Windows CE-specific routines for TIFF Library. - * Adapted from tif_win32.c 01/10/2006 by Mateusz Loskot (mateusz@loskot.net) - */ - -#ifndef _WIN32_WCE -# error "Only Windows CE target is supported!" -#endif - -#include "tiffiop.h" -#include <windows.h> - -/* Turn off console support on Windows CE. */ -#undef TIF_PLATFORM_CONSOLE - - -/* - * Open a TIFF file for read/writing. - */ -TIFF* -TIFFOpen(const char* name, const char* mode) -{ - static const char module[] = "TIFFOpen"; - thandle_t fd; - int m; - DWORD dwMode; - TIFF* tif; - size_t nLen; - size_t nWideLen; - wchar_t* wchName; - - m = _TIFFgetMode(mode, module); - - switch(m) - { - case O_RDONLY: - dwMode = OPEN_EXISTING; - break; - case O_RDWR: - dwMode = OPEN_ALWAYS; - break; - case O_RDWR|O_CREAT: - dwMode = OPEN_ALWAYS; - break; - case O_RDWR|O_TRUNC: - dwMode = CREATE_ALWAYS; - break; - case O_RDWR|O_CREAT|O_TRUNC: - dwMode = CREATE_ALWAYS; - break; - default: - return ((TIFF*)0); - } - - /* On Windows CE, CreateFile is mapped to CreateFileW, - * but file path is passed as char-based string, - * so the path has to be converted to wchar_t. - */ - - nWideLen = 0; - wchName = NULL; - nLen = strlen(name) + 1; - - nWideLen = MultiByteToWideChar(CP_ACP, 0, name, nLen, NULL, 0); - wchName = (wchar_t*)malloc(sizeof(wchar_t) * nWideLen); - if (NULL == wchName) - { - TIFFErrorExt(0, module, "Memory allocation error!"); - return ((TIFF *)0); - } - memset(wchName, 0, sizeof(wchar_t) * nWideLen); - MultiByteToWideChar(CP_ACP, 0, name, nLen, wchName, nWideLen); - - fd = (thandle_t)CreateFile(wchName, - (m == O_RDONLY)?GENERIC_READ:(GENERIC_READ | GENERIC_WRITE), - FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, dwMode, - (m == O_RDONLY)?FILE_ATTRIBUTE_READONLY:FILE_ATTRIBUTE_NORMAL, - NULL); - - free(wchName); - - if (fd == INVALID_HANDLE_VALUE) { - TIFFErrorExt(0, module, "%s: Cannot open", name); - return ((TIFF *)0); - } - - /* TODO - mloskot: change to TIFFdOpenW and pass wchar path */ - - tif = TIFFFdOpen((int)fd, name, mode); - if(!tif) - CloseHandle(fd); - return tif; -} - -/* - * Open a TIFF file with a Unicode filename, for read/writing. - */ -TIFF* -TIFFOpenW(const wchar_t* name, const char* mode) -{ - static const char module[] = "TIFFOpenW"; - thandle_t fd; - int m; - DWORD dwMode; - int mbsize; - char *mbname; - TIFF *tif; - - m = _TIFFgetMode(mode, module); - - switch(m) { - case O_RDONLY: dwMode = OPEN_EXISTING; break; - case O_RDWR: dwMode = OPEN_ALWAYS; break; - case O_RDWR|O_CREAT: dwMode = OPEN_ALWAYS; break; - case O_RDWR|O_TRUNC: dwMode = CREATE_ALWAYS; break; - case O_RDWR|O_CREAT|O_TRUNC: dwMode = CREATE_ALWAYS; break; - default: return ((TIFF*)0); - } - - /* On Windows CE, CreateFile is mapped to CreateFileW, - * so no conversion of wchar_t to char is required. - */ - - fd = (thandle_t)CreateFile(name, - (m == O_RDONLY)?GENERIC_READ:(GENERIC_READ|GENERIC_WRITE), - FILE_SHARE_READ, NULL, dwMode, - (m == O_RDONLY)?FILE_ATTRIBUTE_READONLY:FILE_ATTRIBUTE_NORMAL, - NULL); - if (fd == INVALID_HANDLE_VALUE) { - TIFFErrorExt(0, module, "%S: Cannot open", name); - return ((TIFF *)0); - } - - mbname = NULL; - mbsize = WideCharToMultiByte(CP_ACP, 0, name, -1, NULL, 0, NULL, NULL); - if (mbsize > 0) { - mbname = (char *)_TIFFmalloc(mbsize); - if (!mbname) { - TIFFErrorExt(0, module, - "Can't allocate space for filename conversion buffer"); - return ((TIFF*)0); - } - - WideCharToMultiByte(CP_ACP, 0, name, -1, mbname, mbsize, - NULL, NULL); - } - - tif = TIFFFdOpen((int)fd, - (mbname != NULL) ? mbname : "<unknown>", mode); - if(!tif) - CloseHandle(fd); - - _TIFFfree(mbname); - - return tif; -} - -static void -Win32WarningHandler(const char* module, const char* fmt, va_list ap) -{ - /* On Windows CE, MessageBox is mapped to wide-char based MessageBoxW. */ - - size_t nWideLen = 0; - LPTSTR szWideTitle = NULL; - LPTSTR szWideMsg = NULL; - - LPSTR szTitle; - LPSTR szTmp; - LPCSTR szTitleText = "%s Warning"; - LPCSTR szDefaultModule = "LIBTIFF"; - LPCSTR szTmpModule; - - szTmpModule = (module == NULL) ? szDefaultModule : module; - if ((szTitle = (LPSTR)LocalAlloc(LMEM_FIXED, - (strlen(szTmpModule) + strlen(szTitleText) - + strlen(fmt) + 128) * sizeof(char))) == NULL) - return; - - sprintf(szTitle, szTitleText, szTmpModule); - szTmp = szTitle + (strlen(szTitle) + 2) * sizeof(char); - vsprintf(szTmp, fmt, ap); - - /* Convert error message to Unicode. */ - - nWideLen = MultiByteToWideChar(CP_ACP, 0, szTitle, -1, NULL, 0); - szWideTitle = (wchar_t*)malloc(sizeof(wchar_t) * nWideLen); - MultiByteToWideChar(CP_ACP, 0, szTitle, -1, szWideTitle, nWideLen); - - nWideLen = MultiByteToWideChar(CP_ACP, 0, szTmp, -1, NULL, 0); - szWideMsg = (wchar_t*)malloc(sizeof(wchar_t) * nWideLen); - MultiByteToWideChar(CP_ACP, 0, szTmp, -1, szWideMsg, nWideLen); - - /* Display message */ - - MessageBox(GetFocus(), szWideMsg, szWideTitle, MB_OK | MB_ICONEXCLAMATION); - - /* Free resources */ - - LocalFree(szTitle); - free(szWideMsg); - free(szWideTitle); -} - -TIFFErrorHandler _TIFFwarningHandler = Win32WarningHandler; - -static void -Win32ErrorHandler(const char* module, const char* fmt, va_list ap) -{ - /* On Windows CE, MessageBox is mapped to wide-char based MessageBoxW. */ - - size_t nWideLen = 0; - LPTSTR szWideTitle = NULL; - LPTSTR szWideMsg = NULL; - - LPSTR szTitle; - LPSTR szTmp; - LPCSTR szTitleText = "%s Error"; - LPCSTR szDefaultModule = "LIBTIFF"; - LPCSTR szTmpModule; - - szTmpModule = (module == NULL) ? szDefaultModule : module; - if ((szTitle = (LPSTR)LocalAlloc(LMEM_FIXED, - (strlen(szTmpModule) + strlen(szTitleText) - + strlen(fmt) + 128) * sizeof(char))) == NULL) - return; - - sprintf(szTitle, szTitleText, szTmpModule); - szTmp = szTitle + (strlen(szTitle) + 2) * sizeof(char); - vsprintf(szTmp, fmt, ap); - - /* Convert error message to Unicode. */ - - nWideLen = MultiByteToWideChar(CP_ACP, 0, szTitle, -1, NULL, 0); - szWideTitle = (wchar_t*)malloc(sizeof(wchar_t) * nWideLen); - MultiByteToWideChar(CP_ACP, 0, szTitle, -1, szWideTitle, nWideLen); - - nWideLen = MultiByteToWideChar(CP_ACP, 0, szTmp, -1, NULL, 0); - szWideMsg = (wchar_t*)malloc(sizeof(wchar_t) * nWideLen); - MultiByteToWideChar(CP_ACP, 0, szTmp, -1, szWideMsg, nWideLen); - - /* Display message */ - - MessageBox(GetFocus(), szWideMsg, szWideTitle, MB_OK | MB_ICONEXCLAMATION); - - /* Free resources */ - - LocalFree(szTitle); - free(szWideMsg); - free(szWideTitle); -} - -TIFFErrorHandler _TIFFerrorHandler = Win32ErrorHandler; - - -/* vim: set ts=8 sts=8 sw=8 noet: */ diff --git a/src/3rdparty/libtiff/libtiff/tif_write.c b/src/3rdparty/libtiff/libtiff/tif_write.c index ec37136..8792123 100644 --- a/src/3rdparty/libtiff/libtiff/tif_write.c +++ b/src/3rdparty/libtiff/libtiff/tif_write.c @@ -1,26 +1,26 @@ -/* $Id: tif_write.c,v 1.22.2.4 2009-08-28 02:23:19 bfriesen Exp $ */ +/* $Id: tif_write.c,v 1.37 2012-08-13 22:10:17 fwarmerdam Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * - * Permission to use, copy, modify, distribute, and sell this software and + * 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. - * + * + * 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 + * 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. */ @@ -32,26 +32,26 @@ #include "tiffiop.h" #include <stdio.h> -#define STRIPINCR 20 /* expansion factor on strip array */ +#define STRIPINCR 20 /* expansion factor on strip array */ -#define WRITECHECKSTRIPS(tif, module) \ +#define WRITECHECKSTRIPS(tif, module) \ (((tif)->tif_flags&TIFF_BEENWRITING) || TIFFWriteCheck((tif),0,module)) -#define WRITECHECKTILES(tif, module) \ +#define WRITECHECKTILES(tif, module) \ (((tif)->tif_flags&TIFF_BEENWRITING) || TIFFWriteCheck((tif),1,module)) -#define BUFFERCHECK(tif) \ +#define BUFFERCHECK(tif) \ ((((tif)->tif_flags & TIFF_BUFFERSETUP) && tif->tif_rawdata) || \ - TIFFWriteBufferSetup((tif), NULL, (tsize_t) -1)) + TIFFWriteBufferSetup((tif), NULL, (tmsize_t) -1)) -static int TIFFGrowStrips(TIFF*, int, const char*); -static int TIFFAppendToStrip(TIFF*, tstrip_t, tidata_t, tsize_t); +static int TIFFGrowStrips(TIFF* tif, uint32 delta, const char* module); +static int TIFFAppendToStrip(TIFF* tif, uint32 strip, uint8* data, tmsize_t cc); int -TIFFWriteScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample) +TIFFWriteScanline(TIFF* tif, void* buf, uint32 row, uint16 sample) { static const char module[] = "TIFFWriteScanline"; register TIFFDirectory *td; int status, imagegrew = 0; - tstrip_t strip; + uint32 strip; if (!WRITECHECKSTRIPS(tif, module)) return (-1); @@ -62,6 +62,8 @@ TIFFWriteScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample) */ if (!BUFFERCHECK(tif)) return (-1); + tif->tif_flags |= TIFF_BUF4WRITE; /* not strictly sure this is right*/ + td = &tif->tif_dir; /* * Extend image length if needed @@ -69,8 +71,8 @@ TIFFWriteScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample) */ if (row >= td->td_imagelength) { /* extend image */ if (td->td_planarconfig == PLANARCONFIG_SEPARATE) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Can not change \"ImageLength\" when using separate planes"); + TIFFErrorExt(tif->tif_clientdata, module, + "Can not change \"ImageLength\" when using separate planes"); return (-1); } td->td_imagelength = row+1; @@ -81,9 +83,9 @@ TIFFWriteScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample) */ if (td->td_planarconfig == PLANARCONFIG_SEPARATE) { if (sample >= td->td_samplesperpixel) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "%d: Sample out of range, max %d", - sample, td->td_samplesperpixel); + TIFFErrorExt(tif->tif_clientdata, module, + "%lu: Sample out of range, max %lu", + (unsigned long) sample, (unsigned long) td->td_samplesperpixel); return (-1); } strip = sample*td->td_stripsperimage + row/td->td_rowsperstrip; @@ -112,7 +114,7 @@ TIFFWriteScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample) */ if (strip >= td->td_stripsperimage && imagegrew) td->td_stripsperimage = - TIFFhowmany(td->td_imagelength,td->td_rowsperstrip); + TIFFhowmany_32(td->td_imagelength,td->td_rowsperstrip); tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip; if ((tif->tif_flags & TIFF_CODERSETUP) == 0) { @@ -161,10 +163,10 @@ TIFFWriteScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample) tif->tif_row = row; } - /* swab if needed - note that source buffer will be altered */ - tif->tif_postdecode( tif, (tidata_t) buf, tif->tif_scanlinesize ); + /* swab if needed - note that source buffer will be altered */ + tif->tif_postdecode( tif, (uint8*) buf, tif->tif_scanlinesize ); - status = (*tif->tif_encoderow)(tif, (tidata_t) buf, + status = (*tif->tif_encoderow)(tif, (uint8*) buf, tif->tif_scanlinesize, sample); /* we are now poised at the beginning of the next row */ @@ -178,15 +180,15 @@ TIFFWriteScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample) * * NB: Image length must be setup before writing. */ -tsize_t -TIFFWriteEncodedStrip(TIFF* tif, tstrip_t strip, tdata_t data, tsize_t cc) +tmsize_t +TIFFWriteEncodedStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc) { static const char module[] = "TIFFWriteEncodedStrip"; TIFFDirectory *td = &tif->tif_dir; - tsample_t sample; + uint16 sample; if (!WRITECHECKSTRIPS(tif, module)) - return ((tsize_t) -1); + return ((tmsize_t) -1); /* * Check strip array to make sure there's space. * We don't support dynamically growing files that @@ -198,14 +200,14 @@ TIFFWriteEncodedStrip(TIFF* tif, tstrip_t strip, tdata_t data, tsize_t cc) */ if (strip >= td->td_nstrips) { if (td->td_planarconfig == PLANARCONFIG_SEPARATE) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Can not grow image by strips when using separate planes"); - return ((tsize_t) -1); + TIFFErrorExt(tif->tif_clientdata, module, + "Can not grow image by strips when using separate planes"); + return ((tmsize_t) -1); } if (!TIFFGrowStrips(tif, 1, module)) - return ((tsize_t) -1); + return ((tmsize_t) -1); td->td_stripsperimage = - TIFFhowmany(td->td_imagelength, td->td_rowsperstrip); + TIFFhowmany_32(td->td_imagelength, td->td_rowsperstrip); } /* * Handle delayed allocation of data buffer. This @@ -213,43 +215,57 @@ TIFFWriteEncodedStrip(TIFF* tif, tstrip_t strip, tdata_t data, tsize_t cc) * info. */ if (!BUFFERCHECK(tif)) - return ((tsize_t) -1); + return ((tmsize_t) -1); + + tif->tif_flags |= TIFF_BUF4WRITE; tif->tif_curstrip = strip; + tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip; if ((tif->tif_flags & TIFF_CODERSETUP) == 0) { if (!(*tif->tif_setupencode)(tif)) - return ((tsize_t) -1); + return ((tmsize_t) -1); tif->tif_flags |= TIFF_CODERSETUP; } - - tif->tif_rawcc = 0; - tif->tif_rawcp = tif->tif_rawdata; - if( td->td_stripbytecount[strip] > 0 ) + if( td->td_stripbytecount[strip] > 0 ) { + /* Make sure that at the first attempt of rewriting the tile, we will have */ + /* more bytes available in the output buffer than the previous byte count, */ + /* so that TIFFAppendToStrip() will detect the overflow when it is called the first */ + /* time if the new compressed tile is bigger than the older one. (GDAL #4771) */ + if( tif->tif_rawdatasize <= td->td_stripbytecount[strip] ) + { + if( !(TIFFWriteBufferSetup(tif, NULL, + (tmsize_t)TIFFroundup_64((uint64)(td->td_stripbytecount[strip] + 1), 1024))) ) + return ((tmsize_t)(-1)); + } + /* Force TIFFAppendToStrip() to consider placing data at end of file. */ tif->tif_curoff = 0; } - + + tif->tif_rawcc = 0; + tif->tif_rawcp = tif->tif_rawdata; + tif->tif_flags &= ~TIFF_POSTENCODE; - sample = (tsample_t)(strip / td->td_stripsperimage); + sample = (uint16)(strip / td->td_stripsperimage); if (!(*tif->tif_preencode)(tif, sample)) - return ((tsize_t) -1); + return ((tmsize_t) -1); /* swab if needed - note that source buffer will be altered */ - tif->tif_postdecode( tif, (tidata_t) data, cc ); + tif->tif_postdecode( tif, (uint8*) data, cc ); - if (!(*tif->tif_encodestrip)(tif, (tidata_t) data, cc, sample)) - return ((tsize_t) 0); + if (!(*tif->tif_encodestrip)(tif, (uint8*) data, cc, sample)) + return (0); if (!(*tif->tif_postencode)(tif)) - return ((tsize_t) -1); + return ((tmsize_t) -1); if (!isFillOrder(tif, td->td_fillorder) && (tif->tif_flags & TIFF_NOBITREV) == 0) TIFFReverseBits(tif->tif_rawdata, tif->tif_rawcc); if (tif->tif_rawcc > 0 && !TIFFAppendToStrip(tif, strip, tif->tif_rawdata, tif->tif_rawcc)) - return ((tsize_t) -1); + return ((tmsize_t) -1); tif->tif_rawcc = 0; tif->tif_rawcp = tif->tif_rawdata; return (cc); @@ -260,14 +276,14 @@ TIFFWriteEncodedStrip(TIFF* tif, tstrip_t strip, tdata_t data, tsize_t cc) * * NB: Image length must be setup before writing. */ -tsize_t -TIFFWriteRawStrip(TIFF* tif, tstrip_t strip, tdata_t data, tsize_t cc) +tmsize_t +TIFFWriteRawStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc) { static const char module[] = "TIFFWriteRawStrip"; TIFFDirectory *td = &tif->tif_dir; if (!WRITECHECKSTRIPS(tif, module)) - return ((tsize_t) -1); + return ((tmsize_t) -1); /* * Check strip array to make sure there's space. * We don't support dynamically growing files that @@ -279,9 +295,9 @@ TIFFWriteRawStrip(TIFF* tif, tstrip_t strip, tdata_t data, tsize_t cc) */ if (strip >= td->td_nstrips) { if (td->td_planarconfig == PLANARCONFIG_SEPARATE) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, - "Can not grow image by strips when using separate planes"); - return ((tsize_t) -1); + TIFFErrorExt(tif->tif_clientdata, module, + "Can not grow image by strips when using separate planes"); + return ((tmsize_t) -1); } /* * Watch out for a growing image. The value of @@ -290,26 +306,25 @@ TIFFWriteRawStrip(TIFF* tif, tstrip_t strip, tdata_t data, tsize_t cc) */ if (strip >= td->td_stripsperimage) td->td_stripsperimage = - TIFFhowmany(td->td_imagelength,td->td_rowsperstrip); + TIFFhowmany_32(td->td_imagelength,td->td_rowsperstrip); if (!TIFFGrowStrips(tif, 1, module)) - return ((tsize_t) -1); + return ((tmsize_t) -1); } tif->tif_curstrip = strip; tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip; - return (TIFFAppendToStrip(tif, strip, (tidata_t) data, cc) ? - cc : (tsize_t) -1); + return (TIFFAppendToStrip(tif, strip, (uint8*) data, cc) ? + cc : (tmsize_t) -1); } /* * Write and compress a tile of data. The * tile is selected by the (x,y,z,s) coordinates. */ -tsize_t -TIFFWriteTile(TIFF* tif, - tdata_t buf, uint32 x, uint32 y, uint32 z, tsample_t s) +tmsize_t +TIFFWriteTile(TIFF* tif, void* buf, uint32 x, uint32 y, uint32 z, uint16 s) { if (!TIFFCheckTile(tif, x, y, z, s)) - return (-1); + return ((tmsize_t)(-1)); /* * NB: A tile size of -1 is used instead of tif_tilesize knowing * that TIFFWriteEncodedTile will clamp this to the tile size. @@ -317,7 +332,7 @@ TIFFWriteTile(TIFF* tif, * after the output buffer is setup in TIFFWriteBufferSetup. */ return (TIFFWriteEncodedTile(tif, - TIFFComputeTile(tif, x, y, z, s), buf, (tsize_t) -1)); + TIFFComputeTile(tif, x, y, z, s), buf, (tmsize_t)(-1))); } /* @@ -332,20 +347,20 @@ TIFFWriteTile(TIFF* tif, * interface does not support automatically growing * the image on each write (as TIFFWriteScanline does). */ -tsize_t -TIFFWriteEncodedTile(TIFF* tif, ttile_t tile, tdata_t data, tsize_t cc) +tmsize_t +TIFFWriteEncodedTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc) { static const char module[] = "TIFFWriteEncodedTile"; TIFFDirectory *td; - tsample_t sample; + uint16 sample; if (!WRITECHECKTILES(tif, module)) - return ((tsize_t) -1); + return ((tmsize_t)(-1)); td = &tif->tif_dir; if (tile >= td->td_nstrips) { - TIFFErrorExt(tif->tif_clientdata, module, "%s: Tile %lu out of range, max %lu", - tif->tif_name, (unsigned long) tile, (unsigned long) td->td_nstrips); - return ((tsize_t) -1); + TIFFErrorExt(tif->tif_clientdata, module, "Tile %lu out of range, max %lu", + (unsigned long) tile, (unsigned long) td->td_nstrips); + return ((tmsize_t)(-1)); } /* * Handle delayed allocation of data buffer. This @@ -353,37 +368,50 @@ TIFFWriteEncodedTile(TIFF* tif, ttile_t tile, tdata_t data, tsize_t cc) * directory information). */ if (!BUFFERCHECK(tif)) - return ((tsize_t) -1); - tif->tif_curtile = tile; + return ((tmsize_t)(-1)); - tif->tif_rawcc = 0; - tif->tif_rawcp = tif->tif_rawdata; + tif->tif_flags |= TIFF_BUF4WRITE; + tif->tif_curtile = tile; - if( td->td_stripbytecount[tile] > 0 ) + if( td->td_stripbytecount[tile] > 0 ) { + /* Make sure that at the first attempt of rewriting the tile, we will have */ + /* more bytes available in the output buffer than the previous byte count, */ + /* so that TIFFAppendToStrip() will detect the overflow when it is called the first */ + /* time if the new compressed tile is bigger than the older one. (GDAL #4771) */ + if( tif->tif_rawdatasize <= td->td_stripbytecount[tile] ) + { + if( !(TIFFWriteBufferSetup(tif, NULL, + (tmsize_t)TIFFroundup_64((uint64)(td->td_stripbytecount[tile] + 1), 1024))) ) + return ((tmsize_t)(-1)); + } + /* Force TIFFAppendToStrip() to consider placing data at end of file. */ tif->tif_curoff = 0; } - + + tif->tif_rawcc = 0; + tif->tif_rawcp = tif->tif_rawdata; + /* * Compute tiles per row & per column to compute * current row and column */ - tif->tif_row = (tile % TIFFhowmany(td->td_imagelength, td->td_tilelength)) + tif->tif_row = (tile % TIFFhowmany_32(td->td_imagelength, td->td_tilelength)) * td->td_tilelength; - tif->tif_col = (tile % TIFFhowmany(td->td_imagewidth, td->td_tilewidth)) + tif->tif_col = (tile % TIFFhowmany_32(td->td_imagewidth, td->td_tilewidth)) * td->td_tilewidth; if ((tif->tif_flags & TIFF_CODERSETUP) == 0) { if (!(*tif->tif_setupencode)(tif)) - return ((tsize_t) -1); + return ((tmsize_t)(-1)); tif->tif_flags |= TIFF_CODERSETUP; } tif->tif_flags &= ~TIFF_POSTENCODE; - sample = (tsample_t)(tile/td->td_stripsperimage); + sample = (uint16)(tile/td->td_stripsperimage); if (!(*tif->tif_preencode)(tif, sample)) - return ((tsize_t) -1); + return ((tmsize_t)(-1)); /* * Clamp write amount to the tile size. This is mostly * done so that callers can pass in some large number @@ -393,18 +421,18 @@ TIFFWriteEncodedTile(TIFF* tif, ttile_t tile, tdata_t data, tsize_t cc) cc = tif->tif_tilesize; /* swab if needed - note that source buffer will be altered */ - tif->tif_postdecode( tif, (tidata_t) data, cc ); + tif->tif_postdecode( tif, (uint8*) data, cc ); - if (!(*tif->tif_encodetile)(tif, (tidata_t) data, cc, sample)) - return ((tsize_t) 0); + if (!(*tif->tif_encodetile)(tif, (uint8*) data, cc, sample)) + return (0); if (!(*tif->tif_postencode)(tif)) - return ((tsize_t) -1); + return ((tmsize_t)(-1)); if (!isFillOrder(tif, td->td_fillorder) && (tif->tif_flags & TIFF_NOBITREV) == 0) - TIFFReverseBits((unsigned char *)tif->tif_rawdata, tif->tif_rawcc); + TIFFReverseBits((uint8*)tif->tif_rawdata, tif->tif_rawcc); if (tif->tif_rawcc > 0 && !TIFFAppendToStrip(tif, tile, tif->tif_rawdata, tif->tif_rawcc)) - return ((tsize_t) -1); + return ((tmsize_t)(-1)); tif->tif_rawcc = 0; tif->tif_rawcp = tif->tif_rawdata; return (cc); @@ -419,21 +447,21 @@ TIFFWriteEncodedTile(TIFF* tif, ttile_t tile, tdata_t data, tsize_t cc) * interface does not support automatically growing * the image on each write (as TIFFWriteScanline does). */ -tsize_t -TIFFWriteRawTile(TIFF* tif, ttile_t tile, tdata_t data, tsize_t cc) +tmsize_t +TIFFWriteRawTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc) { static const char module[] = "TIFFWriteRawTile"; if (!WRITECHECKTILES(tif, module)) - return ((tsize_t) -1); + return ((tmsize_t)(-1)); if (tile >= tif->tif_dir.td_nstrips) { - TIFFErrorExt(tif->tif_clientdata, module, "%s: Tile %lu out of range, max %lu", - tif->tif_name, (unsigned long) tile, + TIFFErrorExt(tif->tif_clientdata, module, "Tile %lu out of range, max %lu", + (unsigned long) tile, (unsigned long) tif->tif_dir.td_nstrips); - return ((tsize_t) -1); + return ((tmsize_t)(-1)); } - return (TIFFAppendToStrip(tif, tile, (tidata_t) data, cc) ? - cc : (tsize_t) -1); + return (TIFFAppendToStrip(tif, tile, (uint8*) data, cc) ? + cc : (tmsize_t)(-1)); } #define isUnspecified(tif, f) \ @@ -455,18 +483,18 @@ TIFFSetupStrips(TIFF* tif) td->td_nstrips = td->td_stripsperimage; if (td->td_planarconfig == PLANARCONFIG_SEPARATE) td->td_stripsperimage /= td->td_samplesperpixel; - td->td_stripoffset = (uint32 *) - _TIFFmalloc(td->td_nstrips * sizeof (uint32)); - td->td_stripbytecount = (uint32 *) - _TIFFmalloc(td->td_nstrips * sizeof (uint32)); + td->td_stripoffset = (uint64 *) + _TIFFmalloc(td->td_nstrips * sizeof (uint64)); + td->td_stripbytecount = (uint64 *) + _TIFFmalloc(td->td_nstrips * sizeof (uint64)); if (td->td_stripoffset == NULL || td->td_stripbytecount == NULL) return (0); /* * Place data at the end-of-file * (by setting offsets to zero). */ - _TIFFmemset(td->td_stripoffset, 0, td->td_nstrips*sizeof (uint32)); - _TIFFmemset(td->td_stripbytecount, 0, td->td_nstrips*sizeof (uint32)); + _TIFFmemset(td->td_stripoffset, 0, td->td_nstrips*sizeof (uint64)); + _TIFFmemset(td->td_stripbytecount, 0, td->td_nstrips*sizeof (uint64)); TIFFSetFieldBit(tif, FIELD_STRIPOFFSETS); TIFFSetFieldBit(tif, FIELD_STRIPBYTECOUNTS); return (1); @@ -483,16 +511,17 @@ int TIFFWriteCheck(TIFF* tif, int tiles, const char* module) { if (tif->tif_mode == O_RDONLY) { - TIFFErrorExt(tif->tif_clientdata, module, "%s: File not open for writing", - tif->tif_name); + TIFFErrorExt(tif->tif_clientdata, module, "File not open for writing"); return (0); } if (tiles ^ isTiled(tif)) { - TIFFErrorExt(tif->tif_clientdata, tif->tif_name, tiles ? + TIFFErrorExt(tif->tif_clientdata, module, tiles ? "Can not write tiles to a stripped image" : "Can not write scanlines to a tiled image"); return (0); } + + _TIFFFillStriles( tif ); /* * On the first write verify all the required information @@ -506,8 +535,7 @@ TIFFWriteCheck(TIFF* tif, int tiles, const char* module) */ if (!TIFFFieldSet(tif, FIELD_IMAGEDIMENSIONS)) { TIFFErrorExt(tif->tif_clientdata, module, - "%s: Must set \"ImageWidth\" before writing data", - tif->tif_name); + "Must set \"ImageWidth\" before writing data"); return (0); } if (tif->tif_dir.td_samplesperpixel == 1) { @@ -522,19 +550,27 @@ TIFFWriteCheck(TIFF* tif, int tiles, const char* module) } else { if (!TIFFFieldSet(tif, FIELD_PLANARCONFIG)) { TIFFErrorExt(tif->tif_clientdata, module, - "%s: Must set \"PlanarConfiguration\" before writing data", - tif->tif_name); + "Must set \"PlanarConfiguration\" before writing data"); return (0); } } if (tif->tif_dir.td_stripoffset == NULL && !TIFFSetupStrips(tif)) { tif->tif_dir.td_nstrips = 0; - TIFFErrorExt(tif->tif_clientdata, module, "%s: No space for %s arrays", - tif->tif_name, isTiled(tif) ? "tile" : "strip"); + TIFFErrorExt(tif->tif_clientdata, module, "No space for %s arrays", + isTiled(tif) ? "tile" : "strip"); return (0); } - tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tsize_t) -1; + if (isTiled(tif)) + { + tif->tif_tilesize = TIFFTileSize(tif); + if (tif->tif_tilesize == 0) + return (0); + } + else + tif->tif_tilesize = (tmsize_t)(-1); tif->tif_scanlinesize = TIFFScanlineSize(tif); + if (tif->tif_scanlinesize == 0) + return (0); tif->tif_flags |= TIFF_BEENWRITING; return (1); } @@ -543,7 +579,7 @@ TIFFWriteCheck(TIFF* tif, int tiles, const char* module) * Setup the raw data buffer used for encoding. */ int -TIFFWriteBufferSetup(TIFF* tif, tdata_t bp, tsize_t size) +TIFFWriteBufferSetup(TIFF* tif, void* bp, tmsize_t size) { static const char module[] = "TIFFWriteBufferSetup"; @@ -554,7 +590,7 @@ TIFFWriteBufferSetup(TIFF* tif, tdata_t bp, tsize_t size) } tif->tif_rawdata = NULL; } - if (size == (tsize_t) -1) { + if (size == (tmsize_t)(-1)) { size = (isTiled(tif) ? tif->tif_tilesize : TIFFStripSize(tif)); /* @@ -567,14 +603,13 @@ TIFFWriteBufferSetup(TIFF* tif, tdata_t bp, tsize_t size) if (bp == NULL) { bp = _TIFFmalloc(size); if (bp == NULL) { - TIFFErrorExt(tif->tif_clientdata, module, "%s: No space for output buffer", - tif->tif_name); + TIFFErrorExt(tif->tif_clientdata, module, "No space for output buffer"); return (0); } tif->tif_flags |= TIFF_MYBUFFER; } else tif->tif_flags &= ~TIFF_MYBUFFER; - tif->tif_rawdata = (tidata_t) bp; + tif->tif_rawdata = (uint8*) bp; tif->tif_rawdatasize = size; tif->tif_rawcc = 0; tif->tif_rawcp = tif->tif_rawdata; @@ -586,33 +621,35 @@ TIFFWriteBufferSetup(TIFF* tif, tdata_t bp, tsize_t size) * Grow the strip data structures by delta strips. */ static int -TIFFGrowStrips(TIFF* tif, int delta, const char* module) +TIFFGrowStrips(TIFF* tif, uint32 delta, const char* module) { - TIFFDirectory *td = &tif->tif_dir; - uint32 *new_stripoffset, *new_stripbytecount; + TIFFDirectory *td = &tif->tif_dir; + uint64* new_stripoffset; + uint64* new_stripbytecount; assert(td->td_planarconfig == PLANARCONFIG_CONTIG); - new_stripoffset = (uint32*)_TIFFrealloc(td->td_stripoffset, - (td->td_nstrips + delta) * sizeof (uint32)); - new_stripbytecount = (uint32*)_TIFFrealloc(td->td_stripbytecount, - (td->td_nstrips + delta) * sizeof (uint32)); + new_stripoffset = (uint64*)_TIFFrealloc(td->td_stripoffset, + (td->td_nstrips + delta) * sizeof (uint64)); + new_stripbytecount = (uint64*)_TIFFrealloc(td->td_stripbytecount, + (td->td_nstrips + delta) * sizeof (uint64)); if (new_stripoffset == NULL || new_stripbytecount == NULL) { if (new_stripoffset) _TIFFfree(new_stripoffset); if (new_stripbytecount) _TIFFfree(new_stripbytecount); td->td_nstrips = 0; - TIFFErrorExt(tif->tif_clientdata, module, "%s: No space to expand strip arrays", - tif->tif_name); + TIFFErrorExt(tif->tif_clientdata, module, "No space to expand strip arrays"); return (0); } td->td_stripoffset = new_stripoffset; td->td_stripbytecount = new_stripbytecount; _TIFFmemset(td->td_stripoffset + td->td_nstrips, - 0, delta*sizeof (uint32)); + 0, delta*sizeof (uint64)); _TIFFmemset(td->td_stripbytecount + td->td_nstrips, - 0, delta*sizeof (uint32)); + 0, delta*sizeof (uint64)); td->td_nstrips += delta; + tif->tif_flags |= TIFF_DIRTYDIRECT; + return (1); } @@ -620,21 +657,23 @@ TIFFGrowStrips(TIFF* tif, int delta, const char* module) * Append the data to the specified strip. */ static int -TIFFAppendToStrip(TIFF* tif, tstrip_t strip, tidata_t data, tsize_t cc) +TIFFAppendToStrip(TIFF* tif, uint32 strip, uint8* data, tmsize_t cc) { static const char module[] = "TIFFAppendToStrip"; TIFFDirectory *td = &tif->tif_dir; + uint64 m; + int64 old_byte_count = -1; if (td->td_stripoffset[strip] == 0 || tif->tif_curoff == 0) { assert(td->td_nstrips > 0); if( td->td_stripbytecount[strip] != 0 && td->td_stripoffset[strip] != 0 - && td->td_stripbytecount[strip] >= cc ) + && td->td_stripbytecount[strip] >= (uint64) cc ) { /* * There is already tile data on disk, and the new tile - * data we have to will fit in the same space. The only + * data we have will fit in the same space. The only * aspect of this that is risky is that there could be * more data to append to this strip before we are done * depending on how we are getting called. @@ -653,6 +692,7 @@ TIFFAppendToStrip(TIFF* tif, tstrip_t strip, tidata_t data, tsize_t cc) * write this strip. */ td->td_stripoffset[strip] = TIFFSeekFile(tif, 0, SEEK_END); + tif->tif_flags |= TIFF_DIRTYSTRIP; } tif->tif_curoff = td->td_stripoffset[strip]; @@ -660,16 +700,29 @@ TIFFAppendToStrip(TIFF* tif, tstrip_t strip, tidata_t data, tsize_t cc) /* * We are starting a fresh strip/tile, so set the size to zero. */ + old_byte_count = td->td_stripbytecount[strip]; td->td_stripbytecount[strip] = 0; } + m = tif->tif_curoff+cc; + if (!(tif->tif_flags&TIFF_BIGTIFF)) + m = (uint32)m; + if ((m<tif->tif_curoff)||(m<(uint64)cc)) + { + TIFFErrorExt(tif->tif_clientdata, module, "Maximum TIFF file size exceeded"); + return (0); + } if (!WriteOK(tif, data, cc)) { TIFFErrorExt(tif->tif_clientdata, module, "Write error at scanline %lu", (unsigned long) tif->tif_row); return (0); } - tif->tif_curoff = tif->tif_curoff+cc; + tif->tif_curoff = m; td->td_stripbytecount[strip] += cc; + + if( (int64) td->td_stripbytecount[strip] != old_byte_count ) + tif->tif_flags |= TIFF_DIRTYSTRIP; + return (1); } @@ -681,10 +734,10 @@ TIFFAppendToStrip(TIFF* tif, tstrip_t strip, tidata_t data, tsize_t cc) int TIFFFlushData1(TIFF* tif) { - if (tif->tif_rawcc > 0) { + if (tif->tif_rawcc > 0 && tif->tif_flags & TIFF_BUF4WRITE ) { if (!isFillOrder(tif, tif->tif_dir.td_fillorder) && (tif->tif_flags & TIFF_NOBITREV) == 0) - TIFFReverseBits((unsigned char *)tif->tif_rawdata, + TIFFReverseBits((uint8*)tif->tif_rawdata, tif->tif_rawcc); if (!TIFFAppendToStrip(tif, isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip, @@ -709,3 +762,10 @@ TIFFSetWriteOffset(TIFF* tif, toff_t off) } /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tif_zip.c b/src/3rdparty/libtiff/libtiff/tif_zip.c index 38a5773..f5aa2a9 100644 --- a/src/3rdparty/libtiff/libtiff/tif_zip.c +++ b/src/3rdparty/libtiff/libtiff/tif_zip.c @@ -1,4 +1,4 @@ -/* $Id: tif_zip.c,v 1.11.2.3 2007/11/22 21:24:51 fwarmerdam Exp $ */ +/* $Id: tif_zip.c,v 1.31 2011-01-06 16:00:23 fwarmerdam Exp $ */ /* * Copyright (c) 1995-1997 Sam Leffler @@ -65,41 +65,48 @@ * State block for each open TIFF * file using ZIP compression/decompression. */ -typedef struct { +typedef struct { TIFFPredictorState predict; - z_stream stream; - int zipquality; /* compression level */ - int state; /* state flags */ + z_stream stream; + int zipquality; /* compression level */ + int state; /* state flags */ #define ZSTATE_INIT_DECODE 0x01 #define ZSTATE_INIT_ENCODE 0x02 - TIFFVGetMethod vgetparent; /* super-class method */ - TIFFVSetMethod vsetparent; /* super-class method */ + TIFFVGetMethod vgetparent; /* super-class method */ + TIFFVSetMethod vsetparent; /* super-class method */ } ZIPState; -#define ZState(tif) ((ZIPState*) (tif)->tif_data) -#define DecoderState(tif) ZState(tif) -#define EncoderState(tif) ZState(tif) +#define ZState(tif) ((ZIPState*) (tif)->tif_data) +#define DecoderState(tif) ZState(tif) +#define EncoderState(tif) ZState(tif) -static int ZIPEncode(TIFF*, tidata_t, tsize_t, tsample_t); -static int ZIPDecode(TIFF*, tidata_t, tsize_t, tsample_t); +static int ZIPEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s); +static int ZIPDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s); + +static int +ZIPFixupTags(TIFF* tif) +{ + (void) tif; + return (1); +} static int ZIPSetupDecode(TIFF* tif) { - ZIPState* sp = DecoderState(tif); static const char module[] = "ZIPSetupDecode"; + ZIPState* sp = DecoderState(tif); assert(sp != NULL); /* if we were last encoding, terminate this mode */ if (sp->state & ZSTATE_INIT_ENCODE) { - deflateEnd(&sp->stream); - sp->state = 0; - } + deflateEnd(&sp->stream); + sp->state = 0; + } if (inflateInit(&sp->stream) != Z_OK) { - TIFFErrorExt(tif->tif_clientdata, module, "%s: %s", tif->tif_name, sp->stream.msg); + TIFFErrorExt(tif->tif_clientdata, module, "%s", sp->stream.msg); return (0); } else { sp->state |= ZSTATE_INIT_DECODE; @@ -111,74 +118,100 @@ ZIPSetupDecode(TIFF* tif) * Setup state for decoding a strip. */ static int -ZIPPreDecode(TIFF* tif, tsample_t s) +ZIPPreDecode(TIFF* tif, uint16 s) { + static const char module[] = "ZIPPreDecode"; ZIPState* sp = DecoderState(tif); (void) s; assert(sp != NULL); - if( (sp->state & ZSTATE_INIT_DECODE) == 0 ) + if( (sp->state & ZSTATE_INIT_DECODE) == 0 ) tif->tif_setupdecode( tif ); sp->stream.next_in = tif->tif_rawdata; - sp->stream.avail_in = tif->tif_rawcc; + assert(sizeof(sp->stream.avail_in)==4); /* if this assert gets raised, + we need to simplify this code to reflect a ZLib that is likely updated + to deal with 8byte memory sizes, though this code will respond + apropriately even before we simplify it */ + sp->stream.avail_in = (uInt) tif->tif_rawcc; + if ((tmsize_t)sp->stream.avail_in != tif->tif_rawcc) + { + TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size"); + return (0); + } return (inflateReset(&sp->stream) == Z_OK); } static int -ZIPDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) +ZIPDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s) { - ZIPState* sp = DecoderState(tif); static const char module[] = "ZIPDecode"; + ZIPState* sp = DecoderState(tif); (void) s; assert(sp != NULL); - assert(sp->state == ZSTATE_INIT_DECODE); + assert(sp->state == ZSTATE_INIT_DECODE); + sp->stream.next_in = tif->tif_rawcp; + sp->stream.avail_in = (uInt) tif->tif_rawcc; + sp->stream.next_out = op; - sp->stream.avail_out = occ; + assert(sizeof(sp->stream.avail_out)==4); /* if this assert gets raised, + we need to simplify this code to reflect a ZLib that is likely updated + to deal with 8byte memory sizes, though this code will respond + apropriately even before we simplify it */ + sp->stream.avail_out = (uInt) occ; + if ((tmsize_t)sp->stream.avail_out != occ) + { + TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size"); + return (0); + } do { int state = inflate(&sp->stream, Z_PARTIAL_FLUSH); if (state == Z_STREAM_END) break; if (state == Z_DATA_ERROR) { TIFFErrorExt(tif->tif_clientdata, module, - "%s: Decoding error at scanline %d, %s", - tif->tif_name, tif->tif_row, sp->stream.msg); + "Decoding error at scanline %lu, %s", + (unsigned long) tif->tif_row, sp->stream.msg); if (inflateSync(&sp->stream) != Z_OK) return (0); continue; } if (state != Z_OK) { - TIFFErrorExt(tif->tif_clientdata, module, "%s: zlib error: %s", - tif->tif_name, sp->stream.msg); + TIFFErrorExt(tif->tif_clientdata, module, "ZLib error: %s", + sp->stream.msg); return (0); } } while (sp->stream.avail_out > 0); if (sp->stream.avail_out != 0) { TIFFErrorExt(tif->tif_clientdata, module, - "%s: Not enough data at scanline %d (short %d bytes)", - tif->tif_name, tif->tif_row, sp->stream.avail_out); + "Not enough data at scanline %lu (short " TIFF_UINT64_FORMAT " bytes)", + (unsigned long) tif->tif_row, (TIFF_UINT64_T) sp->stream.avail_out); return (0); } + + tif->tif_rawcp = sp->stream.next_in; + tif->tif_rawcc = sp->stream.avail_in; + return (1); } static int ZIPSetupEncode(TIFF* tif) { - ZIPState* sp = EncoderState(tif); static const char module[] = "ZIPSetupEncode"; + ZIPState* sp = EncoderState(tif); assert(sp != NULL); if (sp->state & ZSTATE_INIT_DECODE) { - inflateEnd(&sp->stream); - sp->state = 0; - } + inflateEnd(&sp->stream); + sp->state = 0; + } if (deflateInit(&sp->stream, sp->zipquality) != Z_OK) { - TIFFErrorExt(tif->tif_clientdata, module, "%s: %s", tif->tif_name, sp->stream.msg); + TIFFErrorExt(tif->tif_clientdata, module, "%s", sp->stream.msg); return (0); } else { sp->state |= ZSTATE_INIT_ENCODE; @@ -190,17 +223,27 @@ ZIPSetupEncode(TIFF* tif) * Reset encoding state at the start of a strip. */ static int -ZIPPreEncode(TIFF* tif, tsample_t s) +ZIPPreEncode(TIFF* tif, uint16 s) { + static const char module[] = "ZIPPreEncode"; ZIPState *sp = EncoderState(tif); (void) s; assert(sp != NULL); - if( sp->state != ZSTATE_INIT_ENCODE ) + if( sp->state != ZSTATE_INIT_ENCODE ) tif->tif_setupencode( tif ); sp->stream.next_out = tif->tif_rawdata; + assert(sizeof(sp->stream.avail_out)==4); /* if this assert gets raised, + we need to simplify this code to reflect a ZLib that is likely updated + to deal with 8byte memory sizes, though this code will respond + apropriately even before we simplify it */ sp->stream.avail_out = tif->tif_rawdatasize; + if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize) + { + TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size"); + return (0); + } return (deflateReset(&sp->stream) == Z_OK); } @@ -208,28 +251,37 @@ ZIPPreEncode(TIFF* tif, tsample_t s) * Encode a chunk of pixels. */ static int -ZIPEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) +ZIPEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s) { - ZIPState *sp = EncoderState(tif); static const char module[] = "ZIPEncode"; + ZIPState *sp = EncoderState(tif); - assert(sp != NULL); - assert(sp->state == ZSTATE_INIT_ENCODE); + assert(sp != NULL); + assert(sp->state == ZSTATE_INIT_ENCODE); (void) s; sp->stream.next_in = bp; - sp->stream.avail_in = cc; + assert(sizeof(sp->stream.avail_in)==4); /* if this assert gets raised, + we need to simplify this code to reflect a ZLib that is likely updated + to deal with 8byte memory sizes, though this code will respond + apropriately even before we simplify it */ + sp->stream.avail_in = (uInt) cc; + if ((tmsize_t)sp->stream.avail_in != cc) + { + TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size"); + return (0); + } do { if (deflate(&sp->stream, Z_NO_FLUSH) != Z_OK) { - TIFFErrorExt(tif->tif_clientdata, module, "%s: Encoder error: %s", - tif->tif_name, sp->stream.msg); + TIFFErrorExt(tif->tif_clientdata, module, "Encoder error: %s", + sp->stream.msg); return (0); } if (sp->stream.avail_out == 0) { tif->tif_rawcc = tif->tif_rawdatasize; TIFFFlushData1(tif); sp->stream.next_out = tif->tif_rawdata; - sp->stream.avail_out = tif->tif_rawdatasize; + sp->stream.avail_out = (uInt) tif->tif_rawdatasize; /* this is a safe typecast, as check is made already in ZIPPreEncode */ } } while (sp->stream.avail_in > 0); return (1); @@ -242,8 +294,8 @@ ZIPEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) static int ZIPPostEncode(TIFF* tif) { - ZIPState *sp = EncoderState(tif); static const char module[] = "ZIPPostEncode"; + ZIPState *sp = EncoderState(tif); int state; sp->stream.avail_in = 0; @@ -252,19 +304,18 @@ ZIPPostEncode(TIFF* tif) switch (state) { case Z_STREAM_END: case Z_OK: - if ((int)sp->stream.avail_out != (int)tif->tif_rawdatasize) - { - tif->tif_rawcc = - tif->tif_rawdatasize - sp->stream.avail_out; - TIFFFlushData1(tif); - sp->stream.next_out = tif->tif_rawdata; - sp->stream.avail_out = tif->tif_rawdatasize; - } - break; + if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize) + { + tif->tif_rawcc = tif->tif_rawdatasize - sp->stream.avail_out; + TIFFFlushData1(tif); + sp->stream.next_out = tif->tif_rawdata; + sp->stream.avail_out = (uInt) tif->tif_rawdatasize; /* this is a safe typecast, as check is made already in ZIPPreEncode */ + } + break; default: - TIFFErrorExt(tif->tif_clientdata, module, "%s: zlib error: %s", - tif->tif_name, sp->stream.msg); - return (0); + TIFFErrorExt(tif->tif_clientdata, module, "ZLib error: %s", + sp->stream.msg); + return (0); } } while (state != Z_STREAM_END); return (1); @@ -283,11 +334,11 @@ ZIPCleanup(TIFF* tif) tif->tif_tagmethods.vsetfield = sp->vsetparent; if (sp->state & ZSTATE_INIT_ENCODE) { - deflateEnd(&sp->stream); - sp->state = 0; - } else if( sp->state & ZSTATE_INIT_DECODE) { - inflateEnd(&sp->stream); - sp->state = 0; + deflateEnd(&sp->stream); + sp->state = 0; + } else if( sp->state & ZSTATE_INIT_DECODE) { + inflateEnd(&sp->stream); + sp->state = 0; } _TIFFfree(sp); tif->tif_data = NULL; @@ -296,19 +347,19 @@ ZIPCleanup(TIFF* tif) } static int -ZIPVSetField(TIFF* tif, ttag_t tag, va_list ap) +ZIPVSetField(TIFF* tif, uint32 tag, va_list ap) { - ZIPState* sp = ZState(tif); static const char module[] = "ZIPVSetField"; + ZIPState* sp = ZState(tif); switch (tag) { case TIFFTAG_ZIPQUALITY: - sp->zipquality = va_arg(ap, int); + sp->zipquality = (int) va_arg(ap, int); if ( sp->state&ZSTATE_INIT_ENCODE ) { if (deflateParams(&sp->stream, sp->zipquality, Z_DEFAULT_STRATEGY) != Z_OK) { - TIFFErrorExt(tif->tif_clientdata, module, "%s: zlib error: %s", - tif->tif_name, sp->stream.msg); + TIFFErrorExt(tif->tif_clientdata, module, "ZLib error: %s", + sp->stream.msg); return (0); } } @@ -320,7 +371,7 @@ ZIPVSetField(TIFF* tif, ttag_t tag, va_list ap) } static int -ZIPVGetField(TIFF* tif, ttag_t tag, va_list ap) +ZIPVGetField(TIFF* tif, uint32 tag, va_list ap) { ZIPState* sp = ZState(tif); @@ -334,9 +385,8 @@ ZIPVGetField(TIFF* tif, ttag_t tag, va_list ap) return (1); } -static const TIFFFieldInfo zipFieldInfo[] = { - { TIFFTAG_ZIPQUALITY, 0, 0, TIFF_ANY, FIELD_PSEUDO, - TRUE, FALSE, "" }, +static const TIFFField zipFields[] = { + { TIFFTAG_ZIPQUALITY, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "", NULL }, }; int @@ -351,8 +401,7 @@ TIFFInitZIP(TIFF* tif, int scheme) /* * Merge codec-specific tag information. */ - if (!_TIFFMergeFieldInfo(tif, zipFieldInfo, - TIFFArrayCount(zipFieldInfo))) { + if (!_TIFFMergeFields(tif, zipFields, TIFFArrayCount(zipFields))) { TIFFErrorExt(tif->tif_clientdata, module, "Merging Deflate codec-specific tags failed"); return 0; @@ -361,7 +410,7 @@ TIFFInitZIP(TIFF* tif, int scheme) /* * Allocate state block so tag methods have storage to record values. */ - tif->tif_data = (tidata_t) _TIFFmalloc(sizeof (ZIPState)); + tif->tif_data = (uint8*) _TIFFmalloc(sizeof (ZIPState)); if (tif->tif_data == NULL) goto bad; sp = ZState(tif); @@ -385,11 +434,12 @@ TIFFInitZIP(TIFF* tif, int scheme) /* * Install codec methods. */ + tif->tif_fixuptags = ZIPFixupTags; tif->tif_setupdecode = ZIPSetupDecode; tif->tif_predecode = ZIPPreDecode; tif->tif_decoderow = ZIPDecode; tif->tif_decodestrip = ZIPDecode; - tif->tif_decodetile = ZIPDecode; + tif->tif_decodetile = ZIPDecode; tif->tif_setupencode = ZIPSetupEncode; tif->tif_preencode = ZIPPreEncode; tif->tif_postencode = ZIPPostEncode; @@ -410,3 +460,10 @@ bad: #endif /* ZIP_SUPORT */ /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tiff.h b/src/3rdparty/libtiff/libtiff/tiff.h index 8211671..19b4e79 100644 --- a/src/3rdparty/libtiff/libtiff/tiff.h +++ b/src/3rdparty/libtiff/libtiff/tiff.h @@ -1,4 +1,4 @@ -/* $Id: tiff.h,v 1.43 2006-10-05 15:20:40 dron Exp $ */ +/* $Id: tiff.h,v 1.68 2012-08-19 16:56:35 bfriesen Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler @@ -39,86 +39,74 @@ * Suite 200 * Seattle, WA 98104 * 206-622-5500 - * + * * (http://partners.adobe.com/asn/developer/PDFS/TN/TIFF6.pdf) * - * For Big TIFF design notes see the following link + * For BigTIFF design notes see the following links * http://www.remotesensing.org/libtiff/bigtiffdesign.html + * http://www.awaresystems.be/imaging/tiff/bigtiff.html */ -#define TIFF_VERSION 42 -#define TIFF_BIGTIFF_VERSION 43 -#define TIFF_BIGENDIAN 0x4d4d -#define TIFF_LITTLEENDIAN 0x4949 -#define MDI_LITTLEENDIAN 0x5045 -#define MDI_BIGENDIAN 0x4550 +#define TIFF_VERSION_CLASSIC 42 +#define TIFF_VERSION_BIG 43 + +#define TIFF_BIGENDIAN 0x4d4d +#define TIFF_LITTLEENDIAN 0x4949 +#define MDI_LITTLEENDIAN 0x5045 +#define MDI_BIGENDIAN 0x4550 + /* * Intrinsic data types required by the file format: * - * 8-bit quantities int8/uint8 - * 16-bit quantities int16/uint16 - * 32-bit quantities int32/uint32 - * strings unsigned char* + * 8-bit quantities int8/uint8 + * 16-bit quantities int16/uint16 + * 32-bit quantities int32/uint32 + * 64-bit quantities int64/uint64 + * strings unsigned char* */ -#ifndef HAVE_INT8 -typedef signed char int8; /* NB: non-ANSI compilers may not grok */ -#endif -typedef unsigned char uint8; -#ifndef HAVE_INT16 -typedef short int16; -#endif -typedef unsigned short uint16; /* sizeof (uint16) must == 2 */ -#if SIZEOF_INT == 4 -#ifndef HAVE_INT32 -typedef int int32; -#endif -typedef unsigned int uint32; /* sizeof (uint32) must == 4 */ -#elif SIZEOF_LONG == 4 -#ifndef HAVE_INT32 -typedef long int32; -#endif -typedef unsigned long uint32; /* sizeof (uint32) must == 4 */ -#endif +typedef TIFF_INT8_T int8; +typedef TIFF_UINT8_T uint8; -/* For TIFFReassignTagToIgnore */ -enum TIFFIgnoreSense /* IGNORE tag table */ -{ - TIS_STORE, - TIS_EXTRACT, - TIS_EMPTY -}; +typedef TIFF_INT16_T int16; +typedef TIFF_UINT16_T uint16; + +typedef TIFF_INT32_T int32; +typedef TIFF_UINT32_T uint32; + +typedef TIFF_INT64_T int64; +typedef TIFF_UINT64_T uint64; /* - * TIFF header. + * Some types as promoted in a variable argument list + * We use uint16_vap rather then directly using int, because this way + * we document the type we actually want to pass through, conceptually, + * rather then confusing the issue by merely stating the type it gets + * promoted to */ -typedef struct { - uint16 tiff_magic; /* magic number (defines byte order) */ -#define TIFF_MAGIC_SIZE 2 - uint16 tiff_version; /* TIFF version number */ -#define TIFF_VERSION_SIZE 2 - uint32 tiff_diroff; /* byte offset to first directory */ -#define TIFF_DIROFFSET_SIZE 4 -} TIFFHeader; +typedef int uint16_vap; /* - * TIFF Image File Directories are comprised of a table of field - * descriptors of the form shown below. The table is sorted in - * ascending order by tag. The values associated with each entry are - * disjoint and may appear anywhere in the file (so long as they are - * placed on a word boundary). - * - * If the value is 4 bytes or less, then it is placed in the offset - * field to save space. If the value is less than 4 bytes, it is - * left-justified in the offset field. + * TIFF header. */ -typedef struct { - uint16 tdir_tag; /* see below */ - uint16 tdir_type; /* data type; see below */ - uint32 tdir_count; /* number of items; length in spec */ - uint32 tdir_offset; /* byte offset to field data */ -} TIFFDirEntry; +typedef struct { + uint16 tiff_magic; /* magic number (defines byte order) */ + uint16 tiff_version; /* TIFF version number */ +} TIFFHeaderCommon; +typedef struct { + uint16 tiff_magic; /* magic number (defines byte order) */ + uint16 tiff_version; /* TIFF version number */ + uint32 tiff_diroff; /* byte offset to first directory */ +} TIFFHeaderClassic; +typedef struct { + uint16 tiff_magic; /* magic number (defines byte order) */ + uint16 tiff_version; /* TIFF version number */ + uint16 tiff_offsetsize; /* size of offsets, should be 8 */ + uint16 tiff_unused; /* unused word, should be 0 */ + uint64 tiff_diroff; /* byte offset to first directory */ +} TIFFHeaderBig; + /* * NB: In the comments below, @@ -134,21 +122,24 @@ typedef struct { * * Note: RATIONALs are the ratio of two 32-bit integer values. */ -typedef enum { - TIFF_NOTYPE = 0, /* placeholder */ - TIFF_BYTE = 1, /* 8-bit unsigned integer */ - TIFF_ASCII = 2, /* 8-bit bytes w/ last byte null */ - TIFF_SHORT = 3, /* 16-bit unsigned integer */ - TIFF_LONG = 4, /* 32-bit unsigned integer */ - TIFF_RATIONAL = 5, /* 64-bit unsigned fraction */ - TIFF_SBYTE = 6, /* !8-bit signed integer */ - TIFF_UNDEFINED = 7, /* !8-bit untyped data */ - TIFF_SSHORT = 8, /* !16-bit signed integer */ - TIFF_SLONG = 9, /* !32-bit signed integer */ - TIFF_SRATIONAL = 10, /* !64-bit signed fraction */ - TIFF_FLOAT = 11, /* !32-bit IEEE floating point */ - TIFF_DOUBLE = 12, /* !64-bit IEEE floating point */ - TIFF_IFD = 13 /* %32-bit unsigned integer (offset) */ +typedef enum { + TIFF_NOTYPE = 0, /* placeholder */ + TIFF_BYTE = 1, /* 8-bit unsigned integer */ + TIFF_ASCII = 2, /* 8-bit bytes w/ last byte null */ + TIFF_SHORT = 3, /* 16-bit unsigned integer */ + TIFF_LONG = 4, /* 32-bit unsigned integer */ + TIFF_RATIONAL = 5, /* 64-bit unsigned fraction */ + TIFF_SBYTE = 6, /* !8-bit signed integer */ + TIFF_UNDEFINED = 7, /* !8-bit untyped data */ + TIFF_SSHORT = 8, /* !16-bit signed integer */ + TIFF_SLONG = 9, /* !32-bit signed integer */ + TIFF_SRATIONAL = 10, /* !64-bit signed fraction */ + TIFF_FLOAT = 11, /* !32-bit IEEE floating point */ + TIFF_DOUBLE = 12, /* !64-bit IEEE floating point */ + TIFF_IFD = 13, /* %32-bit unsigned integer (offset) */ + TIFF_LONG8 = 16, /* BigTIFF 64-bit unsigned integer */ + TIFF_SLONG8 = 17, /* BigTIFF 64-bit signed integer */ + TIFF_IFD8 = 18 /* BigTIFF 64-bit unsigned integer (offset) */ } TIFFDataType; /* @@ -175,6 +166,8 @@ typedef enum { #define COMPRESSION_LZW 5 /* Lempel-Ziv & Welch */ #define COMPRESSION_OJPEG 6 /* !6.0 JPEG */ #define COMPRESSION_JPEG 7 /* %JPEG DCT compression */ +#define COMPRESSION_T85 9 /* !TIFF/FX T.85 JBIG compression */ +#define COMPRESSION_T43 10 /* !TIFF/FX T.43 colour by layered JBIG compression */ #define COMPRESSION_NEXT 32766 /* NeXT 2-bit RLE */ #define COMPRESSION_CCITTRLEW 32771 /* #1 w/ word alignment */ #define COMPRESSION_PACKBITS 32773 /* Macintosh RLE */ @@ -196,6 +189,7 @@ typedef enum { #define COMPRESSION_SGILOG 34676 /* SGI Log Luminance RLE */ #define COMPRESSION_SGILOG24 34677 /* SGI Log 24-bit packed */ #define COMPRESSION_JP2000 34712 /* Leadtools JPEG2000 */ +#define COMPRESSION_LZMA 34925 /* LZMA2 */ #define TIFFTAG_PHOTOMETRIC 262 /* photometric interpretation */ #define PHOTOMETRIC_MINISWHITE 0 /* min value is white */ #define PHOTOMETRIC_MINISBLACK 1 /* min value is black */ @@ -327,6 +321,30 @@ typedef enum { [Adobe TIFF Technote 3] */ #define TIFFTAG_JPEGTABLES 347 /* %JPEG table stream */ #define TIFFTAG_OPIPROXY 351 /* %OPI Proxy [Adobe TIFF technote] */ +/* Tags 400-435 are from the TIFF/FX spec */ +#define TIFFTAG_GLOBALPARAMETERSIFD 400 /* ! */ +#define TIFFTAG_PROFILETYPE 401 /* ! */ +#define PROFILETYPE_UNSPECIFIED 0 /* ! */ +#define PROFILETYPE_G3_FAX 1 /* ! */ +#define TIFFTAG_FAXPROFILE 402 /* ! */ +#define FAXPROFILE_S 1 /* !TIFF/FX FAX profile S */ +#define FAXPROFILE_F 2 /* !TIFF/FX FAX profile F */ +#define FAXPROFILE_J 3 /* !TIFF/FX FAX profile J */ +#define FAXPROFILE_C 4 /* !TIFF/FX FAX profile C */ +#define FAXPROFILE_L 5 /* !TIFF/FX FAX profile L */ +#define FAXPROFILE_M 6 /* !TIFF/FX FAX profile LM */ +#define TIFFTAG_CODINGMETHODS 403 /* !TIFF/FX coding methods */ +#define CODINGMETHODS_T4_1D (1 << 1) /* !T.4 1D */ +#define CODINGMETHODS_T4_2D (1 << 2) /* !T.4 2D */ +#define CODINGMETHODS_T6 (1 << 3) /* !T.6 */ +#define CODINGMETHODS_T85 (1 << 4) /* !T.85 JBIG */ +#define CODINGMETHODS_T42 (1 << 5) /* !T.42 JPEG */ +#define CODINGMETHODS_T43 (1 << 6) /* !T.43 colour by layered JBIG */ +#define TIFFTAG_VERSIONYEAR 404 /* !TIFF/FX version year */ +#define TIFFTAG_MODENUMBER 405 /* !TIFF/FX mode number */ +#define TIFFTAG_DECODE 433 /* !TIFF/FX decode */ +#define TIFFTAG_IMAGEBASECOLOR 434 /* !TIFF/FX image base colour */ +#define TIFFTAG_T82OPTIONS 435 /* !TIFF/FX T.82 options */ /* * Tags 512-521 are obsoleted by Technical Note #2 which specifies a * revised JPEG-in-TIFF scheme. @@ -348,6 +366,7 @@ typedef enum { #define YCBCRPOSITION_CENTERED 1 /* !as in PostScript Level 2 */ #define YCBCRPOSITION_COSITED 2 /* !as in CCIR 601-1 */ #define TIFFTAG_REFERENCEBLACKWHITE 532 /* !colorimetry info */ +#define TIFFTAG_STRIPROWCOUNTS 559 /* !TIFF/FX strip row counts */ #define TIFFTAG_XMLPACKET 700 /* %XML packet [Adobe XMP Specification, January 2004 */ @@ -414,6 +433,7 @@ typedef enum { #define TIFFTAG_EXIFIFD 34665 /* Pointer to EXIF private directory */ /* tag 34750 is a private tag registered to Adobe? */ #define TIFFTAG_ICCPROFILE 34675 /* ICC profile data */ +#define TIFFTAG_IMAGELAYER 34732 /* !TIFF/FX image layer information */ /* tag 34750 is a private tag registered to Pixel Magic */ #define TIFFTAG_JBIGOPTIONS 34750 /* JBIG options */ #define TIFFTAG_GPSIFD 34853 /* Pointer to GPS private directory */ @@ -576,6 +596,10 @@ typedef enum { #define TIFFTAG_SGILOGENCODE 65561 /* SGILog data encoding control*/ #define SGILOGENCODE_NODITHER 0 /* do not dither encoded values*/ #define SGILOGENCODE_RANDITHER 1 /* randomly dither encd values */ +#define TIFFTAG_LZMAPRESET 65562 /* LZMA2 preset (compression level) */ +#define TIFFTAG_PERSAMPLE 65563 /* interface for per sample tags */ +#define PERSAMPLE_MERGED 0 /* present as a single value */ +#define PERSAMPLE_MULTI 1 /* present as multiple values */ /* * EXIF tags @@ -645,3 +669,10 @@ typedef enum { #endif /* _TIFF_ */ /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tiffconf.h b/src/3rdparty/libtiff/libtiff/tiffconf.h index 1a01222..f37b0b5 100644 --- a/src/3rdparty/libtiff/libtiff/tiffconf.h +++ b/src/3rdparty/libtiff/libtiff/tiffconf.h @@ -9,6 +9,40 @@ #include <qglobal.h> +/* Signed 16-bit type */ +#define TIFF_INT16_T qint16 + +/* Signed 32-bit type */ +#define TIFF_INT32_T qint32 + +/* Signed 64-bit type */ +#define TIFF_INT64_T qint64 + +/* Signed 8-bit type */ +#define TIFF_INT8_T qint8 + +/* Unsigned 16-bit type */ +#define TIFF_UINT16_T quint16 + +/* Unsigned 32-bit type */ +#define TIFF_UINT32_T quint32 + +/* Unsigned 64-bit type */ +#define TIFF_UINT64_T quint64 + +/* Unsigned 8-bit type */ +#define TIFF_UINT8_T quint8 + +/* Signed size type */ +#if QT_POINTER_SIZE == 4 +#define TIFF_SSIZE_T qint32 +#else +#define TIFF_SSIZE_T qint64 +#endif + +/* Pointer difference type */ +#define TIFF_PTRDIFF_T ptrdiff_t + /* Define to 1 if the system has the type `int16'. */ /* #undef HAVE_INT16 */ @@ -18,16 +52,6 @@ /* Define to 1 if the system has the type `int8'. */ /* #undef HAVE_INT8 */ -/* The size of a `int', as computed by sizeof. */ -#define SIZEOF_INT 4 - -/* The size of a `long', as computed by sizeof. */ -#if (QT_POINTER_SIZE == 8) && !defined(Q_OS_WIN64) -#define SIZEOF_LONG 8 -#else -#define SIZEOF_LONG 4 -#endif - /* Compatibility stuff. */ /* Define as 0 or 1 according to the floating point format suported by the diff --git a/src/3rdparty/libtiff/libtiff/tiffconf.h.in b/src/3rdparty/libtiff/libtiff/tiffconf.h.in index 1a52b37..6da9c5a 100644 --- a/src/3rdparty/libtiff/libtiff/tiffconf.h.in +++ b/src/3rdparty/libtiff/libtiff/tiffconf.h.in @@ -7,6 +7,36 @@ #ifndef _TIFFCONF_ #define _TIFFCONF_ +/* Signed 16-bit type */ +#undef TIFF_INT16_T + +/* Signed 32-bit type */ +#undef TIFF_INT32_T + +/* Signed 64-bit type */ +#undef TIFF_INT64_T + +/* Signed 8-bit type */ +#undef TIFF_INT8_T + +/* Unsigned 16-bit type */ +#undef TIFF_UINT16_T + +/* Unsigned 32-bit type */ +#undef TIFF_UINT32_T + +/* Unsigned 64-bit type */ +#undef TIFF_UINT64_T + +/* Unsigned 8-bit type */ +#undef TIFF_UINT8_T + +/* Signed size type */ +#undef TIFF_SSIZE_T + +/* Pointer difference type */ +#undef TIFF_PTRDIFF_T + /* Define to 1 if the system has the type `int16'. */ #undef HAVE_INT16 @@ -16,12 +46,6 @@ /* Define to 1 if the system has the type `int8'. */ #undef HAVE_INT8 -/* The size of a `int', as computed by sizeof. */ -#undef SIZEOF_INT - -/* The size of a `long', as computed by sizeof. */ -#undef SIZEOF_LONG - /* Compatibility stuff. */ /* Define as 0 or 1 according to the floating point format suported by the diff --git a/src/3rdparty/libtiff/libtiff/tiffconf.vc.h b/src/3rdparty/libtiff/libtiff/tiffconf.vc.h index 9a0b152..680f839 100644 --- a/src/3rdparty/libtiff/libtiff/tiffconf.vc.h +++ b/src/3rdparty/libtiff/libtiff/tiffconf.vc.h @@ -19,8 +19,29 @@ /* The size of a `int', as computed by sizeof. */ #define SIZEOF_INT 4 -/* The size of a `long', as computed by sizeof. */ -#define SIZEOF_LONG 4 +/* Signed 8-bit type */ +#define TIFF_INT8_T signed char + +/* Unsigned 8-bit type */ +#define TIFF_UINT8_T unsigned char + +/* Signed 16-bit type */ +#define TIFF_INT16_T signed short + +/* Unsigned 16-bit type */ +#define TIFF_UINT16_T unsigned short + +/* Signed 32-bit type formatter */ +#define TIFF_INT32_FORMAT "%d" + +/* Signed 32-bit type */ +#define TIFF_INT32_T signed int + +/* Unsigned 32-bit type formatter */ +#define TIFF_UINT32_FORMAT "%u" + +/* Unsigned 32-bit type */ +#define TIFF_UINT32_T unsigned int /* Signed 64-bit type formatter */ #define TIFF_INT64_FORMAT "%I64d" @@ -34,6 +55,23 @@ /* Unsigned 64-bit type */ #define TIFF_UINT64_T unsigned __int64 +/* Signed size type */ +#if defined(_WIN64) +#define TIFF_SSIZE_T signed __int64 +#else +#define TIFF_SSIZE_T signed int +#endif + +/* Signed size type formatter */ +#if defined(_WIN64) +#define TIFF_SSIZE_FORMAT "%I64d" +#else +#define TIFF_SSIZE_FORMAT "%ld" +#endif + +/* Pointer difference type */ +#define TIFF_PTRDIFF_T long + /* Compatibility stuff. */ /* Define as 0 or 1 according to the floating point format suported by the @@ -53,6 +91,9 @@ /* Support JPEG compression (requires IJG JPEG library) */ /* #undef JPEG_SUPPORT */ +/* Support JBIG compression (requires JBIG-KIT library) */ +/* #undef JBIG_SUPPORT */ + /* Support LogLuv high dynamic range encoding */ #define LOGLUV_SUPPORT 1 @@ -94,6 +135,9 @@ lacking the tag (default enabled). */ #define CHECK_JPEG_YCBCR_SUBSAMPLING 1 +/* Support MS MDI magic number files as TIFF */ +/* #undef MDI_SUPPORT */ + /* * Feature support definitions. * XXX: These macros are obsoleted. Don't use them in your apps! @@ -107,3 +151,10 @@ #define IPTC_SUPPORT #endif /* _TIFFCONF_ */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tiffconf.wince.h b/src/3rdparty/libtiff/libtiff/tiffconf.wince.h index 27fa239..2ef3958 100644 --- a/src/3rdparty/libtiff/libtiff/tiffconf.wince.h +++ b/src/3rdparty/libtiff/libtiff/tiffconf.wince.h @@ -1,4 +1,4 @@ -/* $Id: tiffconf.wince.h,v 1.1.2.1 2009-01-01 17:52:51 bfriesen Exp $ */ +/* $Id: tiffconf.wince.h,v 1.3 2010-03-10 18:56:49 bfriesen Exp $ */ /* * Windows CE platform tiffconf.wince.h @@ -39,21 +39,6 @@ /* The size of a `int', as computed by sizeof. */ #define SIZEOF_INT 4 -/* The size of a `long', as computed by sizeof. */ -#define SIZEOF_LONG 4 - -/* Signed 64-bit type formatter */ -#define TIFF_INT64_FORMAT "%I64d" - -/* Signed 64-bit type */ -#define TIFF_INT64_T signed __int64 - -/* Unsigned 64-bit type formatter */ -#define TIFF_UINT64_FORMAT "%I64u" - -/* Unsigned 64-bit type */ -#define TIFF_UINT64_T unsigned __int64 - /* Compatibility stuff. */ /* Define as 0 or 1 according to the floating point format suported by the @@ -127,3 +112,10 @@ #define IPTC_SUPPORT #endif /* _TIFFCONF_ */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tiffio.h b/src/3rdparty/libtiff/libtiff/tiffio.h index 0f2735f..038b670 100644 --- a/src/3rdparty/libtiff/libtiff/tiffio.h +++ b/src/3rdparty/libtiff/libtiff/tiffio.h @@ -1,21 +1,21 @@ -/* $Id: tiffio.h,v 1.56.2.3 2009-01-01 00:10:43 bfriesen Exp $ */ +/* $Id: tiffio.h,v 1.91 2012-07-29 15:45:29 tgl Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * - * Permission to use, copy, modify, distribute, and sell this software and + * 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. - * + * + * 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, @@ -37,7 +37,7 @@ * TIFF is defined as an incomplete type to hide the * library's internal data structures from clients. */ -typedef struct tiff TIFF; +typedef struct tiff TIFF; /* * The following typedefs define the intrinsic size of @@ -55,25 +55,32 @@ typedef struct tiff TIFF; * NB: tsize_t is int32 and not uint32 because some functions * return -1. * NB: toff_t is not off_t for many reasons; TIFFs max out at - * 32-bit file offsets being the most important, and to ensure - * that it is unsigned, rather than signed. + * 32-bit file offsets, and BigTIFF maxes out at 64-bit + * offsets being the most important, and to ensure use of + * a consistently unsigned type across architectures. + * Prior to libtiff 4.0, this was an unsigned 32 bit type. */ +/* + * this is the machine addressing size type, only it's signed, so make it + * int32 on 32bit machines, int64 on 64bit machines + */ +typedef TIFF_SSIZE_T tmsize_t; +typedef uint64 toff_t; /* file offset */ +/* the following are deprecated and should be replaced by their defining + counterparts */ typedef uint32 ttag_t; /* directory tag */ typedef uint16 tdir_t; /* directory index */ typedef uint16 tsample_t; /* sample number */ typedef uint32 tstrile_t; /* strip or tile number */ typedef tstrile_t tstrip_t; /* strip number */ typedef tstrile_t ttile_t; /* tile number */ -typedef int32 tsize_t; /* i/o size in bytes */ +typedef tmsize_t tsize_t; /* i/o size in bytes */ typedef void* tdata_t; /* image data ref */ -typedef uint32 toff_t; /* file offset */ #if !defined(__WIN32__) && (defined(_WIN32) || defined(WIN32)) #define __WIN32__ #endif -#include <stdlib.h> - /* * On windows you should define USE_WIN32_FILEIO if you are using tif_win32.c * or AVOID_WIN32_FILEIO if you are using something else (like tif_unix.c). @@ -91,12 +98,12 @@ typedef uint32 toff_t; /* file offset */ # define VC_EXTRALEAN # include <windows.h> # ifdef __WIN32__ -DECLARE_HANDLE(thandle_t); /* Win32 file handle */ +DECLARE_HANDLE(thandle_t); /* Win32 file handle */ # else -typedef HFILE thandle_t; /* client data handle */ +typedef HFILE thandle_t; /* client data handle */ # endif /* __WIN32__ */ #else -typedef void* thandle_t; /* client data handle */ +typedef void* thandle_t; /* client data handle */ #endif /* USE_WIN32_FILEIO */ /* @@ -105,13 +112,13 @@ typedef void* thandle_t; /* client data handle */ * very large. Bit-or these flags to enable printing * multiple items. */ -#define TIFFPRINT_NONE 0x0 /* no extra info */ -#define TIFFPRINT_STRIPS 0x1 /* strips/tiles info */ -#define TIFFPRINT_CURVES 0x2 /* color/gray response curves */ -#define TIFFPRINT_COLORMAP 0x4 /* colormap */ -#define TIFFPRINT_JPEGQTABLES 0x100 /* JPEG Q matrices */ -#define TIFFPRINT_JPEGACTABLES 0x200 /* JPEG AC tables */ -#define TIFFPRINT_JPEGDCTABLES 0x200 /* JPEG DC tables */ +#define TIFFPRINT_NONE 0x0 /* no extra info */ +#define TIFFPRINT_STRIPS 0x1 /* strips/tiles info */ +#define TIFFPRINT_CURVES 0x2 /* color/gray response curves */ +#define TIFFPRINT_COLORMAP 0x4 /* colormap */ +#define TIFFPRINT_JPEGQTABLES 0x100 /* JPEG Q matrices */ +#define TIFFPRINT_JPEGACTABLES 0x200 /* JPEG AC tables */ +#define TIFFPRINT_JPEGDCTABLES 0x200 /* JPEG DC tables */ /* * Colour conversion stuff @@ -128,42 +135,42 @@ typedef void* thandle_t; /* client data handle */ /* Structure for holding information about a display device. */ -typedef unsigned char TIFFRGBValue; /* 8-bit samples */ +typedef unsigned char TIFFRGBValue; /* 8-bit samples */ typedef struct { - float d_mat[3][3]; /* XYZ -> luminance matrix */ - float d_YCR; /* Light o/p for reference white */ + float d_mat[3][3]; /* XYZ -> luminance matrix */ + float d_YCR; /* Light o/p for reference white */ float d_YCG; float d_YCB; - uint32 d_Vrwr; /* Pixel values for ref. white */ + uint32 d_Vrwr; /* Pixel values for ref. white */ uint32 d_Vrwg; uint32 d_Vrwb; - float d_Y0R; /* Residual light for black pixel */ + float d_Y0R; /* Residual light for black pixel */ float d_Y0G; float d_Y0B; - float d_gammaR; /* Gamma values for the three guns */ + float d_gammaR; /* Gamma values for the three guns */ float d_gammaG; float d_gammaB; } TIFFDisplay; -typedef struct { /* YCbCr->RGB support */ - TIFFRGBValue* clamptab; /* range clamping table */ - int* Cr_r_tab; - int* Cb_b_tab; - int32* Cr_g_tab; - int32* Cb_g_tab; - int32* Y_tab; +typedef struct { /* YCbCr->RGB support */ + TIFFRGBValue* clamptab; /* range clamping table */ + int* Cr_r_tab; + int* Cb_b_tab; + int32* Cr_g_tab; + int32* Cb_g_tab; + int32* Y_tab; } TIFFYCbCrToRGB; -typedef struct { /* CIE Lab 1976->RGB support */ - int range; /* Size of conversion table */ +typedef struct { /* CIE Lab 1976->RGB support */ + int range; /* Size of conversion table */ #define CIELABTORGB_TABLE_RANGE 1500 - float rstep, gstep, bstep; - float X0, Y0, Z0; /* Reference white point */ + float rstep, gstep, bstep; + float X0, Y0, Z0; /* Reference white point */ TIFFDisplay display; - float Yr2r[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yr to r */ - float Yg2g[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yg to g */ - float Yb2b[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yb to b */ + float Yr2r[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yr to r */ + float Yg2g[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yg to g */ + float Yb2b[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yb to b */ } TIFFCIELabToRGB; /* @@ -218,6 +225,9 @@ struct _TIFFRGBAImage { TIFFYCbCrToRGB* ycbcr; /* YCbCr conversion state */ TIFFCIELabToRGB* cielab; /* CIE L*a*b conversion state */ + uint8* UaToAa; /* Unassociated alpha to associated alpha convertion LUT */ + uint8* Bitdepth16To8; /* LUT for conversion from 16bit to 8bit values */ + int row_offset; int col_offset; }; @@ -226,10 +236,10 @@ struct _TIFFRGBAImage { * Macros for extracting components from the * packed ABGR form returned by TIFFReadRGBAImage. */ -#define TIFFGetR(abgr) ((abgr) & 0xff) -#define TIFFGetG(abgr) (((abgr) >> 8) & 0xff) -#define TIFFGetB(abgr) (((abgr) >> 16) & 0xff) -#define TIFFGetA(abgr) (((abgr) >> 24) & 0xff) +#define TIFFGetR(abgr) ((abgr) & 0xff) +#define TIFFGetG(abgr) (((abgr) >> 8) & 0xff) +#define TIFFGetB(abgr) (((abgr) >> 16) & 0xff) +#define TIFFGetA(abgr) (((abgr) >> 24) & 0xff) /* * A CODEC is a software package that implements decoding, @@ -238,11 +248,11 @@ struct _TIFFRGBAImage { * More codecs may be registered through calls to the library * and/or the builtin implementations may be overridden. */ -typedef int (*TIFFInitMethod)(TIFF*, int); +typedef int (*TIFFInitMethod)(TIFF*, int); typedef struct { - char* name; - uint16 scheme; - TIFFInitMethod init; + char* name; + uint16 scheme; + TIFFInitMethod init; } TIFFCodec; #include <stdio.h> @@ -250,7 +260,7 @@ typedef struct { /* share internal LogLuv conversion routines? */ #ifndef LOGLUV_PUBLIC -#define LOGLUV_PUBLIC 1 +#define LOGLUV_PUBLIC 1 #endif #if !defined(__GNUC__) && !defined(__attribute__) @@ -260,258 +270,277 @@ typedef struct { #if defined(c_plusplus) || defined(__cplusplus) extern "C" { #endif -typedef void (*TIFFErrorHandler)(const char*, const char*, va_list); -typedef void (*TIFFErrorHandlerExt)(thandle_t, const char*, const char*, va_list); -typedef tsize_t (*TIFFReadWriteProc)(thandle_t, tdata_t, tsize_t); -typedef toff_t (*TIFFSeekProc)(thandle_t, toff_t, int); -typedef int (*TIFFCloseProc)(thandle_t); -typedef toff_t (*TIFFSizeProc)(thandle_t); -typedef int (*TIFFMapFileProc)(thandle_t, tdata_t*, toff_t*); -typedef void (*TIFFUnmapFileProc)(thandle_t, tdata_t, toff_t); -typedef void (*TIFFExtendProc)(TIFF*); - -extern const char* TIFFGetVersion(void); - -extern const TIFFCodec* TIFFFindCODEC(uint16); -extern TIFFCodec* TIFFRegisterCODEC(uint16, const char*, TIFFInitMethod); -extern void TIFFUnRegisterCODEC(TIFFCodec*); -extern int TIFFIsCODECConfigured(uint16); -extern TIFFCodec* TIFFGetConfiguredCODECs(void); +typedef void (*TIFFErrorHandler)(const char*, const char*, va_list); +typedef void (*TIFFErrorHandlerExt)(thandle_t, const char*, const char*, va_list); +typedef tmsize_t (*TIFFReadWriteProc)(thandle_t, void*, tmsize_t); +typedef toff_t (*TIFFSeekProc)(thandle_t, toff_t, int); +typedef int (*TIFFCloseProc)(thandle_t); +typedef toff_t (*TIFFSizeProc)(thandle_t); +typedef int (*TIFFMapFileProc)(thandle_t, void** base, toff_t* size); +typedef void (*TIFFUnmapFileProc)(thandle_t, void* base, toff_t size); +typedef void (*TIFFExtendProc)(TIFF*); + +extern const char* TIFFGetVersion(void); + +extern const TIFFCodec* TIFFFindCODEC(uint16); +extern TIFFCodec* TIFFRegisterCODEC(uint16, const char*, TIFFInitMethod); +extern void TIFFUnRegisterCODEC(TIFFCodec*); +extern int TIFFIsCODECConfigured(uint16); +extern TIFFCodec* TIFFGetConfiguredCODECs(void); /* * Auxiliary functions. */ -extern tdata_t _TIFFmalloc(tsize_t); -extern tdata_t _TIFFrealloc(tdata_t, tsize_t); -extern void _TIFFmemset(tdata_t, int, tsize_t); -extern void _TIFFmemcpy(tdata_t, const tdata_t, tsize_t); -extern int _TIFFmemcmp(const tdata_t, const tdata_t, tsize_t); -extern void _TIFFfree(tdata_t); +extern void* _TIFFmalloc(tmsize_t s); +extern void* _TIFFrealloc(void* p, tmsize_t s); +extern void _TIFFmemset(void* p, int v, tmsize_t c); +extern void _TIFFmemcpy(void* d, const void* s, tmsize_t c); +extern int _TIFFmemcmp(const void* p1, const void* p2, tmsize_t c); +extern void _TIFFfree(void* p); /* ** Stuff, related to tag handling and creating custom tags. */ -extern int TIFFGetTagListCount( TIFF * ); -extern ttag_t TIFFGetTagListEntry( TIFF *, int tag_index ); +extern int TIFFGetTagListCount( TIFF * ); +extern uint32 TIFFGetTagListEntry( TIFF *, int tag_index ); -#define TIFF_ANY TIFF_NOTYPE /* for field descriptor searching */ -#define TIFF_VARIABLE -1 /* marker for variable length tags */ -#define TIFF_SPP -2 /* marker for SamplesPerPixel tags */ -#define TIFF_VARIABLE2 -3 /* marker for uint32 var-length tags */ +#define TIFF_ANY TIFF_NOTYPE /* for field descriptor searching */ +#define TIFF_VARIABLE -1 /* marker for variable length tags */ +#define TIFF_SPP -2 /* marker for SamplesPerPixel tags */ +#define TIFF_VARIABLE2 -3 /* marker for uint32 var-length tags */ -#define FIELD_CUSTOM 65 +#define FIELD_CUSTOM 65 -typedef struct { - ttag_t field_tag; /* field's tag */ - short field_readcount; /* read count/TIFF_VARIABLE/TIFF_SPP */ - short field_writecount; /* write count/TIFF_VARIABLE */ - TIFFDataType field_type; /* type of associated data */ - unsigned short field_bit; /* bit in fieldsset bit vector */ - unsigned char field_oktochange; /* if true, can change while writing */ - unsigned char field_passcount; /* if true, pass dir count on set */ - char *field_name; /* ASCII name */ -} TIFFFieldInfo; +typedef struct _TIFFField TIFFField; +typedef struct _TIFFFieldArray TIFFFieldArray; + +extern const TIFFField* TIFFFindField(TIFF *, uint32, TIFFDataType); +extern const TIFFField* TIFFFieldWithTag(TIFF*, uint32); +extern const TIFFField* TIFFFieldWithName(TIFF*, const char *); + +extern uint32 TIFFFieldTag(const TIFFField*); +extern const char* TIFFFieldName(const TIFFField*); +extern TIFFDataType TIFFFieldDataType(const TIFFField*); +extern int TIFFFieldPassCount(const TIFFField*); +extern int TIFFFieldReadCount(const TIFFField*); +extern int TIFFFieldWriteCount(const TIFFField*); + +typedef int (*TIFFVSetMethod)(TIFF*, uint32, va_list); +typedef int (*TIFFVGetMethod)(TIFF*, uint32, va_list); +typedef void (*TIFFPrintMethod)(TIFF*, FILE*, long); -typedef struct _TIFFTagValue { - const TIFFFieldInfo *info; - int count; - void *value; -} TIFFTagValue; - -extern void TIFFMergeFieldInfo(TIFF*, const TIFFFieldInfo[], int); -extern const TIFFFieldInfo* TIFFFindFieldInfo(TIFF*, ttag_t, TIFFDataType); -extern const TIFFFieldInfo* TIFFFindFieldInfoByName(TIFF* , const char *, - TIFFDataType); -extern const TIFFFieldInfo* TIFFFieldWithTag(TIFF*, ttag_t); -extern const TIFFFieldInfo* TIFFFieldWithName(TIFF*, const char *); - -typedef int (*TIFFVSetMethod)(TIFF*, ttag_t, va_list); -typedef int (*TIFFVGetMethod)(TIFF*, ttag_t, va_list); -typedef void (*TIFFPrintMethod)(TIFF*, FILE*, long); - typedef struct { - TIFFVSetMethod vsetfield; /* tag set routine */ - TIFFVGetMethod vgetfield; /* tag get routine */ - TIFFPrintMethod printdir; /* directory print routine */ + TIFFVSetMethod vsetfield; /* tag set routine */ + TIFFVGetMethod vgetfield; /* tag get routine */ + TIFFPrintMethod printdir; /* directory print routine */ } TIFFTagMethods; - -extern TIFFTagMethods *TIFFAccessTagMethods( TIFF * ); -extern void *TIFFGetClientInfo( TIFF *, const char * ); -extern void TIFFSetClientInfo( TIFF *, void *, const char * ); - -extern void TIFFCleanup(TIFF*); -extern void TIFFClose(TIFF*); -extern int TIFFFlush(TIFF*); -extern int TIFFFlushData(TIFF*); -extern int TIFFGetField(TIFF*, ttag_t, ...); -extern int TIFFVGetField(TIFF*, ttag_t, va_list); -extern int TIFFGetFieldDefaulted(TIFF*, ttag_t, ...); -extern int TIFFVGetFieldDefaulted(TIFF*, ttag_t, va_list); -extern int TIFFReadDirectory(TIFF*); -extern int TIFFReadCustomDirectory(TIFF*, toff_t, const TIFFFieldInfo[], - size_t); -extern int TIFFReadEXIFDirectory(TIFF*, toff_t); -extern tsize_t TIFFScanlineSize(TIFF*); -extern tsize_t TIFFOldScanlineSize(TIFF*); -extern tsize_t TIFFNewScanlineSize(TIFF*); -extern tsize_t TIFFRasterScanlineSize(TIFF*); -extern tsize_t TIFFStripSize(TIFF*); -extern tsize_t TIFFRawStripSize(TIFF*, tstrip_t); -extern tsize_t TIFFVStripSize(TIFF*, uint32); -extern tsize_t TIFFTileRowSize(TIFF*); -extern tsize_t TIFFTileSize(TIFF*); -extern tsize_t TIFFVTileSize(TIFF*, uint32); -extern uint32 TIFFDefaultStripSize(TIFF*, uint32); -extern void TIFFDefaultTileSize(TIFF*, uint32*, uint32*); -extern int TIFFFileno(TIFF*); -extern int TIFFSetFileno(TIFF*, int); -extern thandle_t TIFFClientdata(TIFF*); -extern thandle_t TIFFSetClientdata(TIFF*, thandle_t); -extern int TIFFGetMode(TIFF*); -extern int TIFFSetMode(TIFF*, int); -extern int TIFFIsTiled(TIFF*); -extern int TIFFIsByteSwapped(TIFF*); -extern int TIFFIsUpSampled(TIFF*); -extern int TIFFIsMSB2LSB(TIFF*); -extern int TIFFIsBigEndian(TIFF*); -extern TIFFReadWriteProc TIFFGetReadProc(TIFF*); -extern TIFFReadWriteProc TIFFGetWriteProc(TIFF*); -extern TIFFSeekProc TIFFGetSeekProc(TIFF*); -extern TIFFCloseProc TIFFGetCloseProc(TIFF*); -extern TIFFSizeProc TIFFGetSizeProc(TIFF*); -extern TIFFMapFileProc TIFFGetMapFileProc(TIFF*); -extern TIFFUnmapFileProc TIFFGetUnmapFileProc(TIFF*); -extern uint32 TIFFCurrentRow(TIFF*); -extern tdir_t TIFFCurrentDirectory(TIFF*); -extern tdir_t TIFFNumberOfDirectories(TIFF*); -extern uint32 TIFFCurrentDirOffset(TIFF*); -extern tstrip_t TIFFCurrentStrip(TIFF*); -extern ttile_t TIFFCurrentTile(TIFF*); -extern int TIFFReadBufferSetup(TIFF*, tdata_t, tsize_t); -extern int TIFFWriteBufferSetup(TIFF*, tdata_t, tsize_t); -extern int TIFFSetupStrips(TIFF *); -extern int TIFFWriteCheck(TIFF*, int, const char *); -extern void TIFFFreeDirectory(TIFF*); -extern int TIFFCreateDirectory(TIFF*); -extern int TIFFLastDirectory(TIFF*); -extern int TIFFSetDirectory(TIFF*, tdir_t); -extern int TIFFSetSubDirectory(TIFF*, uint32); -extern int TIFFUnlinkDirectory(TIFF*, tdir_t); -extern int TIFFSetField(TIFF*, ttag_t, ...); -extern int TIFFVSetField(TIFF*, ttag_t, va_list); -extern int TIFFWriteDirectory(TIFF *); -extern int TIFFCheckpointDirectory(TIFF *); -extern int TIFFRewriteDirectory(TIFF *); -extern int TIFFReassignTagToIgnore(enum TIFFIgnoreSense, int); + +extern TIFFTagMethods *TIFFAccessTagMethods(TIFF *); +extern void *TIFFGetClientInfo(TIFF *, const char *); +extern void TIFFSetClientInfo(TIFF *, void *, const char *); + +extern void TIFFCleanup(TIFF* tif); +extern void TIFFClose(TIFF* tif); +extern int TIFFFlush(TIFF* tif); +extern int TIFFFlushData(TIFF* tif); +extern int TIFFGetField(TIFF* tif, uint32 tag, ...); +extern int TIFFVGetField(TIFF* tif, uint32 tag, va_list ap); +extern int TIFFGetFieldDefaulted(TIFF* tif, uint32 tag, ...); +extern int TIFFVGetFieldDefaulted(TIFF* tif, uint32 tag, va_list ap); +extern int TIFFReadDirectory(TIFF* tif); +extern int TIFFReadCustomDirectory(TIFF* tif, toff_t diroff, const TIFFFieldArray* infoarray); +extern int TIFFReadEXIFDirectory(TIFF* tif, toff_t diroff); +extern uint64 TIFFScanlineSize64(TIFF* tif); +extern tmsize_t TIFFScanlineSize(TIFF* tif); +extern uint64 TIFFRasterScanlineSize64(TIFF* tif); +extern tmsize_t TIFFRasterScanlineSize(TIFF* tif); +extern uint64 TIFFStripSize64(TIFF* tif); +extern tmsize_t TIFFStripSize(TIFF* tif); +extern uint64 TIFFRawStripSize64(TIFF* tif, uint32 strip); +extern tmsize_t TIFFRawStripSize(TIFF* tif, uint32 strip); +extern uint64 TIFFVStripSize64(TIFF* tif, uint32 nrows); +extern tmsize_t TIFFVStripSize(TIFF* tif, uint32 nrows); +extern uint64 TIFFTileRowSize64(TIFF* tif); +extern tmsize_t TIFFTileRowSize(TIFF* tif); +extern uint64 TIFFTileSize64(TIFF* tif); +extern tmsize_t TIFFTileSize(TIFF* tif); +extern uint64 TIFFVTileSize64(TIFF* tif, uint32 nrows); +extern tmsize_t TIFFVTileSize(TIFF* tif, uint32 nrows); +extern uint32 TIFFDefaultStripSize(TIFF* tif, uint32 request); +extern void TIFFDefaultTileSize(TIFF*, uint32*, uint32*); +extern int TIFFFileno(TIFF*); +extern int TIFFSetFileno(TIFF*, int); +extern thandle_t TIFFClientdata(TIFF*); +extern thandle_t TIFFSetClientdata(TIFF*, thandle_t); +extern int TIFFGetMode(TIFF*); +extern int TIFFSetMode(TIFF*, int); +extern int TIFFIsTiled(TIFF*); +extern int TIFFIsByteSwapped(TIFF*); +extern int TIFFIsUpSampled(TIFF*); +extern int TIFFIsMSB2LSB(TIFF*); +extern int TIFFIsBigEndian(TIFF*); +extern TIFFReadWriteProc TIFFGetReadProc(TIFF*); +extern TIFFReadWriteProc TIFFGetWriteProc(TIFF*); +extern TIFFSeekProc TIFFGetSeekProc(TIFF*); +extern TIFFCloseProc TIFFGetCloseProc(TIFF*); +extern TIFFSizeProc TIFFGetSizeProc(TIFF*); +extern TIFFMapFileProc TIFFGetMapFileProc(TIFF*); +extern TIFFUnmapFileProc TIFFGetUnmapFileProc(TIFF*); +extern uint32 TIFFCurrentRow(TIFF*); +extern uint16 TIFFCurrentDirectory(TIFF*); +extern uint16 TIFFNumberOfDirectories(TIFF*); +extern uint64 TIFFCurrentDirOffset(TIFF*); +extern uint32 TIFFCurrentStrip(TIFF*); +extern uint32 TIFFCurrentTile(TIFF* tif); +extern int TIFFReadBufferSetup(TIFF* tif, void* bp, tmsize_t size); +extern int TIFFWriteBufferSetup(TIFF* tif, void* bp, tmsize_t size); +extern int TIFFSetupStrips(TIFF *); +extern int TIFFWriteCheck(TIFF*, int, const char *); +extern void TIFFFreeDirectory(TIFF*); +extern int TIFFCreateDirectory(TIFF*); +extern int TIFFCreateCustomDirectory(TIFF*,const TIFFFieldArray*); +extern int TIFFCreateEXIFDirectory(TIFF*); +extern int TIFFLastDirectory(TIFF*); +extern int TIFFSetDirectory(TIFF*, uint16); +extern int TIFFSetSubDirectory(TIFF*, uint64); +extern int TIFFUnlinkDirectory(TIFF*, uint16); +extern int TIFFSetField(TIFF*, uint32, ...); +extern int TIFFVSetField(TIFF*, uint32, va_list); +extern int TIFFUnsetField(TIFF*, uint32); +extern int TIFFWriteDirectory(TIFF *); +extern int TIFFWriteCustomDirectory(TIFF *, uint64 *); +extern int TIFFCheckpointDirectory(TIFF *); +extern int TIFFRewriteDirectory(TIFF *); #if defined(c_plusplus) || defined(__cplusplus) -extern void TIFFPrintDirectory(TIFF*, FILE*, long = 0); -extern int TIFFReadScanline(TIFF*, tdata_t, uint32, tsample_t = 0); -extern int TIFFWriteScanline(TIFF*, tdata_t, uint32, tsample_t = 0); -extern int TIFFReadRGBAImage(TIFF*, uint32, uint32, uint32*, int = 0); -extern int TIFFReadRGBAImageOriented(TIFF*, uint32, uint32, uint32*, - int = ORIENTATION_BOTLEFT, int = 0); +extern void TIFFPrintDirectory(TIFF*, FILE*, long = 0); +extern int TIFFReadScanline(TIFF* tif, void* buf, uint32 row, uint16 sample = 0); +extern int TIFFWriteScanline(TIFF* tif, void* buf, uint32 row, uint16 sample = 0); +extern int TIFFReadRGBAImage(TIFF*, uint32, uint32, uint32*, int = 0); +extern int TIFFReadRGBAImageOriented(TIFF*, uint32, uint32, uint32*, + int = ORIENTATION_BOTLEFT, int = 0); #else -extern void TIFFPrintDirectory(TIFF*, FILE*, long); -extern int TIFFReadScanline(TIFF*, tdata_t, uint32, tsample_t); -extern int TIFFWriteScanline(TIFF*, tdata_t, uint32, tsample_t); -extern int TIFFReadRGBAImage(TIFF*, uint32, uint32, uint32*, int); -extern int TIFFReadRGBAImageOriented(TIFF*, uint32, uint32, uint32*, int, int); +extern void TIFFPrintDirectory(TIFF*, FILE*, long); +extern int TIFFReadScanline(TIFF* tif, void* buf, uint32 row, uint16 sample); +extern int TIFFWriteScanline(TIFF* tif, void* buf, uint32 row, uint16 sample); +extern int TIFFReadRGBAImage(TIFF*, uint32, uint32, uint32*, int); +extern int TIFFReadRGBAImageOriented(TIFF*, uint32, uint32, uint32*, int, int); #endif -extern int TIFFReadRGBAStrip(TIFF*, tstrip_t, uint32 * ); -extern int TIFFReadRGBATile(TIFF*, uint32, uint32, uint32 * ); -extern int TIFFRGBAImageOK(TIFF*, char [1024]); -extern int TIFFRGBAImageBegin(TIFFRGBAImage*, TIFF*, int, char [1024]); -extern int TIFFRGBAImageGet(TIFFRGBAImage*, uint32*, uint32, uint32); -extern void TIFFRGBAImageEnd(TIFFRGBAImage*); -extern TIFF* TIFFOpen(const char*, const char*); +extern int TIFFReadRGBAStrip(TIFF*, uint32, uint32 * ); +extern int TIFFReadRGBATile(TIFF*, uint32, uint32, uint32 * ); +extern int TIFFRGBAImageOK(TIFF*, char [1024]); +extern int TIFFRGBAImageBegin(TIFFRGBAImage*, TIFF*, int, char [1024]); +extern int TIFFRGBAImageGet(TIFFRGBAImage*, uint32*, uint32, uint32); +extern void TIFFRGBAImageEnd(TIFFRGBAImage*); +extern TIFF* TIFFOpen(const char*, const char*); # ifdef __WIN32__ -extern TIFF* TIFFOpenW(const wchar_t*, const char*); +extern TIFF* TIFFOpenW(const wchar_t*, const char*); # endif /* __WIN32__ */ -extern TIFF* TIFFFdOpen(int, const char*, const char*); -extern TIFF* TIFFClientOpen(const char*, const char*, +extern TIFF* TIFFFdOpen(int, const char*, const char*); +extern TIFF* TIFFClientOpen(const char*, const char*, thandle_t, TIFFReadWriteProc, TIFFReadWriteProc, TIFFSeekProc, TIFFCloseProc, TIFFSizeProc, TIFFMapFileProc, TIFFUnmapFileProc); -extern const char* TIFFFileName(TIFF*); -extern const char* TIFFSetFileName(TIFF*, const char *); -extern void TIFFError(const char*, const char*, ...) __attribute__((format (printf,2,3))); -extern void TIFFErrorExt(thandle_t, const char*, const char*, ...) __attribute__((format (printf,3,4))); -extern void TIFFWarning(const char*, const char*, ...) __attribute__((format (printf,2,3))); -extern void TIFFWarningExt(thandle_t, const char*, const char*, ...) __attribute__((format (printf,3,4))); -extern TIFFErrorHandler TIFFSetErrorHandler(TIFFErrorHandler); -extern TIFFErrorHandlerExt TIFFSetErrorHandlerExt(TIFFErrorHandlerExt); -extern TIFFErrorHandler TIFFSetWarningHandler(TIFFErrorHandler); -extern TIFFErrorHandlerExt TIFFSetWarningHandlerExt(TIFFErrorHandlerExt); -extern TIFFExtendProc TIFFSetTagExtender(TIFFExtendProc); -extern ttile_t TIFFComputeTile(TIFF*, uint32, uint32, uint32, tsample_t); -extern int TIFFCheckTile(TIFF*, uint32, uint32, uint32, tsample_t); -extern ttile_t TIFFNumberOfTiles(TIFF*); -extern tsize_t TIFFReadTile(TIFF*, - tdata_t, uint32, uint32, uint32, tsample_t); -extern tsize_t TIFFWriteTile(TIFF*, - tdata_t, uint32, uint32, uint32, tsample_t); -extern tstrip_t TIFFComputeStrip(TIFF*, uint32, tsample_t); -extern tstrip_t TIFFNumberOfStrips(TIFF*); -extern tsize_t TIFFReadEncodedStrip(TIFF*, tstrip_t, tdata_t, tsize_t); -extern tsize_t TIFFReadRawStrip(TIFF*, tstrip_t, tdata_t, tsize_t); -extern tsize_t TIFFReadEncodedTile(TIFF*, ttile_t, tdata_t, tsize_t); -extern tsize_t TIFFReadRawTile(TIFF*, ttile_t, tdata_t, tsize_t); -extern tsize_t TIFFWriteEncodedStrip(TIFF*, tstrip_t, tdata_t, tsize_t); -extern tsize_t TIFFWriteRawStrip(TIFF*, tstrip_t, tdata_t, tsize_t); -extern tsize_t TIFFWriteEncodedTile(TIFF*, ttile_t, tdata_t, tsize_t); -extern tsize_t TIFFWriteRawTile(TIFF*, ttile_t, tdata_t, tsize_t); -extern int TIFFDataWidth(TIFFDataType); /* table of tag datatype widths */ -extern void TIFFSetWriteOffset(TIFF*, toff_t); -extern void TIFFSwabShort(uint16*); -extern void TIFFSwabLong(uint32*); -extern void TIFFSwabDouble(double*); -extern void TIFFSwabArrayOfShort(uint16*, unsigned long); -extern void TIFFSwabArrayOfTriples(uint8*, unsigned long); -extern void TIFFSwabArrayOfLong(uint32*, unsigned long); -extern void TIFFSwabArrayOfDouble(double*, unsigned long); -extern void TIFFReverseBits(unsigned char *, unsigned long); -extern const unsigned char* TIFFGetBitRevTable(int); +extern const char* TIFFFileName(TIFF*); +extern const char* TIFFSetFileName(TIFF*, const char *); +extern void TIFFError(const char*, const char*, ...) __attribute__((__format__ (__printf__,2,3))); +extern void TIFFErrorExt(thandle_t, const char*, const char*, ...) __attribute__((__format__ (__printf__,3,4))); +extern void TIFFWarning(const char*, const char*, ...) __attribute__((__format__ (__printf__,2,3))); +extern void TIFFWarningExt(thandle_t, const char*, const char*, ...) __attribute__((__format__ (__printf__,3,4))); +extern TIFFErrorHandler TIFFSetErrorHandler(TIFFErrorHandler); +extern TIFFErrorHandlerExt TIFFSetErrorHandlerExt(TIFFErrorHandlerExt); +extern TIFFErrorHandler TIFFSetWarningHandler(TIFFErrorHandler); +extern TIFFErrorHandlerExt TIFFSetWarningHandlerExt(TIFFErrorHandlerExt); +extern TIFFExtendProc TIFFSetTagExtender(TIFFExtendProc); +extern uint32 TIFFComputeTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s); +extern int TIFFCheckTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s); +extern uint32 TIFFNumberOfTiles(TIFF*); +extern tmsize_t TIFFReadTile(TIFF* tif, void* buf, uint32 x, uint32 y, uint32 z, uint16 s); +extern tmsize_t TIFFWriteTile(TIFF* tif, void* buf, uint32 x, uint32 y, uint32 z, uint16 s); +extern uint32 TIFFComputeStrip(TIFF*, uint32, uint16); +extern uint32 TIFFNumberOfStrips(TIFF*); +extern tmsize_t TIFFReadEncodedStrip(TIFF* tif, uint32 strip, void* buf, tmsize_t size); +extern tmsize_t TIFFReadRawStrip(TIFF* tif, uint32 strip, void* buf, tmsize_t size); +extern tmsize_t TIFFReadEncodedTile(TIFF* tif, uint32 tile, void* buf, tmsize_t size); +extern tmsize_t TIFFReadRawTile(TIFF* tif, uint32 tile, void* buf, tmsize_t size); +extern tmsize_t TIFFWriteEncodedStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc); +extern tmsize_t TIFFWriteRawStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc); +extern tmsize_t TIFFWriteEncodedTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc); +extern tmsize_t TIFFWriteRawTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc); +extern int TIFFDataWidth(TIFFDataType); /* table of tag datatype widths */ +extern void TIFFSetWriteOffset(TIFF* tif, toff_t off); +extern void TIFFSwabShort(uint16*); +extern void TIFFSwabLong(uint32*); +extern void TIFFSwabLong8(uint64*); +extern void TIFFSwabFloat(float*); +extern void TIFFSwabDouble(double*); +extern void TIFFSwabArrayOfShort(uint16* wp, tmsize_t n); +extern void TIFFSwabArrayOfTriples(uint8* tp, tmsize_t n); +extern void TIFFSwabArrayOfLong(uint32* lp, tmsize_t n); +extern void TIFFSwabArrayOfLong8(uint64* lp, tmsize_t n); +extern void TIFFSwabArrayOfFloat(float* fp, tmsize_t n); +extern void TIFFSwabArrayOfDouble(double* dp, tmsize_t n); +extern void TIFFReverseBits(uint8* cp, tmsize_t n); +extern const unsigned char* TIFFGetBitRevTable(int); #ifdef LOGLUV_PUBLIC #define U_NEU 0.210526316 #define V_NEU 0.473684211 #define UVSCALE 410. -extern double LogL16toY(int); -extern double LogL10toY(int); -extern void XYZtoRGB24(float*, uint8*); -extern int uv_decode(double*, double*, int); -extern void LogLuv24toXYZ(uint32, float*); -extern void LogLuv32toXYZ(uint32, float*); +extern double LogL16toY(int); +extern double LogL10toY(int); +extern void XYZtoRGB24(float*, uint8*); +extern int uv_decode(double*, double*, int); +extern void LogLuv24toXYZ(uint32, float*); +extern void LogLuv32toXYZ(uint32, float*); #if defined(c_plusplus) || defined(__cplusplus) -extern int LogL16fromY(double, int = SGILOGENCODE_NODITHER); -extern int LogL10fromY(double, int = SGILOGENCODE_NODITHER); -extern int uv_encode(double, double, int = SGILOGENCODE_NODITHER); -extern uint32 LogLuv24fromXYZ(float*, int = SGILOGENCODE_NODITHER); -extern uint32 LogLuv32fromXYZ(float*, int = SGILOGENCODE_NODITHER); +extern int LogL16fromY(double, int = SGILOGENCODE_NODITHER); +extern int LogL10fromY(double, int = SGILOGENCODE_NODITHER); +extern int uv_encode(double, double, int = SGILOGENCODE_NODITHER); +extern uint32 LogLuv24fromXYZ(float*, int = SGILOGENCODE_NODITHER); +extern uint32 LogLuv32fromXYZ(float*, int = SGILOGENCODE_NODITHER); #else -extern int LogL16fromY(double, int); -extern int LogL10fromY(double, int); -extern int uv_encode(double, double, int); -extern uint32 LogLuv24fromXYZ(float*, int); -extern uint32 LogLuv32fromXYZ(float*, int); +extern int LogL16fromY(double, int); +extern int LogL10fromY(double, int); +extern int uv_encode(double, double, int); +extern uint32 LogLuv24fromXYZ(float*, int); +extern uint32 LogLuv32fromXYZ(float*, int); #endif #endif /* LOGLUV_PUBLIC */ - -extern int TIFFCIELabToRGBInit(TIFFCIELabToRGB*, TIFFDisplay *, float*); + +extern int TIFFCIELabToRGBInit(TIFFCIELabToRGB*, const TIFFDisplay *, float*); extern void TIFFCIELabToXYZ(TIFFCIELabToRGB *, uint32, int32, int32, - float *, float *, float *); + float *, float *, float *); extern void TIFFXYZToRGB(TIFFCIELabToRGB *, float, float, float, - uint32 *, uint32 *, uint32 *); + uint32 *, uint32 *, uint32 *); extern int TIFFYCbCrToRGBInit(TIFFYCbCrToRGB*, float*, float*); extern void TIFFYCbCrtoRGB(TIFFYCbCrToRGB *, uint32, int32, int32, - uint32 *, uint32 *, uint32 *); + uint32 *, uint32 *, uint32 *); +/**************************************************************************** + * O B S O L E T E D I N T E R F A C E S + * + * Don't use this stuff in your applications, it may be removed in the future + * libtiff versions. + ****************************************************************************/ +typedef struct { + ttag_t field_tag; /* field's tag */ + short field_readcount; /* read count/TIFF_VARIABLE/TIFF_SPP */ + short field_writecount; /* write count/TIFF_VARIABLE */ + TIFFDataType field_type; /* type of associated data */ + unsigned short field_bit; /* bit in fieldsset bit vector */ + unsigned char field_oktochange; /* if true, can change while writing */ + unsigned char field_passcount; /* if true, pass dir count on set */ + char *field_name; /* ASCII name */ +} TIFFFieldInfo; + +extern int TIFFMergeFieldInfo(TIFF*, const TIFFFieldInfo[], uint32); + #if defined(c_plusplus) || defined(__cplusplus) } #endif @@ -519,3 +548,10 @@ extern void TIFFYCbCrtoRGB(TIFFYCbCrToRGB *, uint32, int32, int32, #endif /* _TIFFIO_ */ /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tiffio.hxx b/src/3rdparty/libtiff/libtiff/tiffio.hxx index ac7b9f2..ed994f1 100644 --- a/src/3rdparty/libtiff/libtiff/tiffio.hxx +++ b/src/3rdparty/libtiff/libtiff/tiffio.hxx @@ -1,4 +1,4 @@ -/* $Id: tiffio.hxx,v 1.1 2004/11/21 16:12:08 dron Exp $ */ +/* $Id: tiffio.hxx,v 1.3 2010-06-08 18:55:15 bfriesen Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler @@ -34,9 +34,16 @@ #include <iostream> #include "tiff.h" -extern TIFF* TIFFStreamOpen(const char*, std::ostream *); -extern TIFF* TIFFStreamOpen(const char*, std::istream *); +extern TIFF* TIFFStreamOpen(const char*, std::ostream *); +extern TIFF* TIFFStreamOpen(const char*, std::istream *); #endif /* _TIFFIO_HXX_ */ /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c++ + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tiffiop.h b/src/3rdparty/libtiff/libtiff/tiffiop.h index 30bb19c..916c998 100644 --- a/src/3rdparty/libtiff/libtiff/tiffiop.h +++ b/src/3rdparty/libtiff/libtiff/tiffiop.h @@ -1,4 +1,4 @@ -/* $Id: tiffiop.h,v 1.51.2.1 2009-01-06 19:08:09 bfriesen Exp $ */ +/* $Id: tiffiop.h,v 1.84 2012-05-30 01:50:17 fwarmerdam Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler @@ -37,12 +37,11 @@ #endif #ifdef HAVE_SYS_TYPES_H -#if !defined(Q_OS_WINCE) -# include <sys/types.h> -#else -# include <windows.h> -# include <types.h> -#endif +# ifdef Q_OS_WINCE +# include <types.h> +# else +# include <sys/types.h> +# endif #endif #ifdef HAVE_STRING_H @@ -62,14 +61,8 @@ extern void *lfind(const void *, const void *, size_t *, size_t, int (*)(const void *, const void *)); #endif -/* - Libtiff itself does not require a 64-bit type, but bundled TIFF - utilities may use it. -*/ -typedef TIFF_INT64_T int64; -typedef TIFF_UINT64_T uint64; - #include "tiffio.h" + #include "tif_dir.h" #ifndef STRIP_SIZE_DEFAULT @@ -85,165 +78,184 @@ typedef TIFF_UINT64_T uint64; typedef struct client_info { struct client_info *next; - void *data; - char *name; + void *data; + char *name; } TIFFClientInfoLink; /* * Typedefs for ``method pointers'' used internally. + * these are depriciated and provided only for backwards compatibility */ -typedef unsigned char tidataval_t; /* internal image data value type */ -typedef tidataval_t* tidata_t; /* reference to internal image data */ - -typedef void (*TIFFVoidMethod)(TIFF*); -typedef int (*TIFFBoolMethod)(TIFF*); -typedef int (*TIFFPreMethod)(TIFF*, tsample_t); -typedef int (*TIFFCodeMethod)(TIFF*, tidata_t, tsize_t, tsample_t); -typedef int (*TIFFSeekMethod)(TIFF*, uint32); -typedef void (*TIFFPostMethod)(TIFF*, tidata_t, tsize_t); -typedef uint32 (*TIFFStripMethod)(TIFF*, uint32); -typedef void (*TIFFTileMethod)(TIFF*, uint32*, uint32*); +typedef unsigned char tidataval_t; /* internal image data value type */ +typedef tidataval_t* tidata_t; /* reference to internal image data */ + +typedef void (*TIFFVoidMethod)(TIFF*); +typedef int (*TIFFBoolMethod)(TIFF*); +typedef int (*TIFFPreMethod)(TIFF*, uint16); +typedef int (*TIFFCodeMethod)(TIFF* tif, uint8* buf, tmsize_t size, uint16 sample); +typedef int (*TIFFSeekMethod)(TIFF*, uint32); +typedef void (*TIFFPostMethod)(TIFF* tif, uint8* buf, tmsize_t size); +typedef uint32 (*TIFFStripMethod)(TIFF*, uint32); +typedef void (*TIFFTileMethod)(TIFF*, uint32*, uint32*); struct tiff { - char* tif_name; /* name of open file */ - int tif_fd; /* open file descriptor */ - int tif_mode; /* open mode (O_*) */ - uint32 tif_flags; -#define TIFF_FILLORDER 0x00003 /* natural bit fill order for machine */ -#define TIFF_DIRTYHEADER 0x00004 /* header must be written on close */ -#define TIFF_DIRTYDIRECT 0x00008 /* current directory must be written */ -#define TIFF_BUFFERSETUP 0x00010 /* data buffers setup */ -#define TIFF_CODERSETUP 0x00020 /* encoder/decoder setup done */ -#define TIFF_BEENWRITING 0x00040 /* written 1+ scanlines to file */ -#define TIFF_SWAB 0x00080 /* byte swap file information */ -#define TIFF_NOBITREV 0x00100 /* inhibit bit reversal logic */ -#define TIFF_MYBUFFER 0x00200 /* my raw data buffer; free on close */ -#define TIFF_ISTILED 0x00400 /* file is tile, not strip- based */ -#define TIFF_MAPPED 0x00800 /* file is mapped into memory */ -#define TIFF_POSTENCODE 0x01000 /* need call to postencode routine */ -#define TIFF_INSUBIFD 0x02000 /* currently writing a subifd */ -#define TIFF_UPSAMPLED 0x04000 /* library is doing data up-sampling */ -#define TIFF_STRIPCHOP 0x08000 /* enable strip chopping support */ -#define TIFF_HEADERONLY 0x10000 /* read header only, do not process */ - /* the first directory */ -#define TIFF_NOREADRAW 0x20000 /* skip reading of raw uncompressed */ - /* image data */ -#define TIFF_INCUSTOMIFD 0x40000 /* currently writing a custom IFD */ - toff_t tif_diroff; /* file offset of current directory */ - toff_t tif_nextdiroff; /* file offset of following directory */ - toff_t* tif_dirlist; /* list of offsets to already seen */ - /* directories to prevent IFD looping */ - tsize_t tif_dirlistsize;/* number of entires in offset list */ - uint16 tif_dirnumber; /* number of already seen directories */ - TIFFDirectory tif_dir; /* internal rep of current directory */ - TIFFDirectory tif_customdir; /* custom IFDs are separated from - the main ones */ - TIFFHeader tif_header; /* file's header block */ - const int* tif_typeshift; /* data type shift counts */ - const long* tif_typemask; /* data type masks */ - uint32 tif_row; /* current scanline */ - tdir_t tif_curdir; /* current directory (index) */ - tstrip_t tif_curstrip; /* current strip for read/write */ - toff_t tif_curoff; /* current offset for read/write */ - toff_t tif_dataoff; /* current offset for writing dir */ -/* SubIFD support */ - uint16 tif_nsubifd; /* remaining subifds to write */ - toff_t tif_subifdoff; /* offset for patching SubIFD link */ -/* tiling support */ - uint32 tif_col; /* current column (offset by row too) */ - ttile_t tif_curtile; /* current tile for read/write */ - tsize_t tif_tilesize; /* # of bytes in a tile */ -/* compression scheme hooks */ - int tif_decodestatus; - TIFFBoolMethod tif_setupdecode;/* called once before predecode */ - TIFFPreMethod tif_predecode; /* pre- row/strip/tile decoding */ - TIFFBoolMethod tif_setupencode;/* called once before preencode */ - int tif_encodestatus; - TIFFPreMethod tif_preencode; /* pre- row/strip/tile encoding */ - TIFFBoolMethod tif_postencode; /* post- row/strip/tile encoding */ - TIFFCodeMethod tif_decoderow; /* scanline decoding routine */ - TIFFCodeMethod tif_encoderow; /* scanline encoding routine */ - TIFFCodeMethod tif_decodestrip;/* strip decoding routine */ - TIFFCodeMethod tif_encodestrip;/* strip encoding routine */ - TIFFCodeMethod tif_decodetile; /* tile decoding routine */ - TIFFCodeMethod tif_encodetile; /* tile encoding routine */ - TIFFVoidMethod tif_close; /* cleanup-on-close routine */ - TIFFSeekMethod tif_seek; /* position within a strip routine */ - TIFFVoidMethod tif_cleanup; /* cleanup state routine */ - TIFFStripMethod tif_defstripsize;/* calculate/constrain strip size */ - TIFFTileMethod tif_deftilesize;/* calculate/constrain tile size */ - tidata_t tif_data; /* compression scheme private data */ -/* input/output buffering */ - tsize_t tif_scanlinesize;/* # of bytes in a scanline */ - tsize_t tif_scanlineskew;/* scanline skew for reading strips */ - tidata_t tif_rawdata; /* raw data buffer */ - tsize_t tif_rawdatasize;/* # of bytes in raw data buffer */ - tidata_t tif_rawcp; /* current spot in raw buffer */ - tsize_t tif_rawcc; /* bytes unread from raw buffer */ -/* memory-mapped file support */ - tidata_t tif_base; /* base of mapped file */ - toff_t tif_size; /* size of mapped file region (bytes) - FIXME: it should be tsize_t */ - TIFFMapFileProc tif_mapproc; /* map file method */ - TIFFUnmapFileProc tif_unmapproc;/* unmap file method */ -/* input/output callback methods */ - thandle_t tif_clientdata; /* callback parameter */ - TIFFReadWriteProc tif_readproc; /* read method */ - TIFFReadWriteProc tif_writeproc;/* write method */ - TIFFSeekProc tif_seekproc; /* lseek method */ - TIFFCloseProc tif_closeproc; /* close method */ - TIFFSizeProc tif_sizeproc; /* filesize method */ -/* post-decoding support */ - TIFFPostMethod tif_postdecode; /* post decoding routine */ -/* tag support */ - TIFFFieldInfo** tif_fieldinfo; /* sorted table of registered tags */ - size_t tif_nfields; /* # entries in registered tag table */ - const TIFFFieldInfo *tif_foundfield;/* cached pointer to already found tag */ - TIFFTagMethods tif_tagmethods; /* tag get/set/print routines */ - TIFFClientInfoLink *tif_clientinfo; /* extra client information. */ + char* tif_name; /* name of open file */ + int tif_fd; /* open file descriptor */ + int tif_mode; /* open mode (O_*) */ + uint32 tif_flags; + #define TIFF_FILLORDER 0x00003 /* natural bit fill order for machine */ + #define TIFF_DIRTYHEADER 0x00004 /* header must be written on close */ + #define TIFF_DIRTYDIRECT 0x00008 /* current directory must be written */ + #define TIFF_BUFFERSETUP 0x00010 /* data buffers setup */ + #define TIFF_CODERSETUP 0x00020 /* encoder/decoder setup done */ + #define TIFF_BEENWRITING 0x00040 /* written 1+ scanlines to file */ + #define TIFF_SWAB 0x00080 /* byte swap file information */ + #define TIFF_NOBITREV 0x00100 /* inhibit bit reversal logic */ + #define TIFF_MYBUFFER 0x00200 /* my raw data buffer; free on close */ + #define TIFF_ISTILED 0x00400 /* file is tile, not strip- based */ + #define TIFF_MAPPED 0x00800 /* file is mapped into memory */ + #define TIFF_POSTENCODE 0x01000 /* need call to postencode routine */ + #define TIFF_INSUBIFD 0x02000 /* currently writing a subifd */ + #define TIFF_UPSAMPLED 0x04000 /* library is doing data up-sampling */ + #define TIFF_STRIPCHOP 0x08000 /* enable strip chopping support */ + #define TIFF_HEADERONLY 0x10000 /* read header only, do not process the first directory */ + #define TIFF_NOREADRAW 0x20000 /* skip reading of raw uncompressed image data */ + #define TIFF_INCUSTOMIFD 0x40000 /* currently writing a custom IFD */ + #define TIFF_BIGTIFF 0x80000 /* read/write bigtiff */ + #define TIFF_BUF4WRITE 0x100000 /* rawcc bytes are for writing */ + #define TIFF_DIRTYSTRIP 0x200000 /* stripoffsets/stripbytecount dirty*/ + #define TIFF_PERSAMPLE 0x400000 /* get/set per sample tags as arrays */ + #define TIFF_BUFFERMMAP 0x800000 /* read buffer (tif_rawdata) points into mmap() memory */ + uint64 tif_diroff; /* file offset of current directory */ + uint64 tif_nextdiroff; /* file offset of following directory */ + uint64* tif_dirlist; /* list of offsets to already seen directories to prevent IFD looping */ + uint16 tif_dirlistsize; /* number of entires in offset list */ + uint16 tif_dirnumber; /* number of already seen directories */ + TIFFDirectory tif_dir; /* internal rep of current directory */ + TIFFDirectory tif_customdir; /* custom IFDs are separated from the main ones */ + union { + TIFFHeaderCommon common; + TIFFHeaderClassic classic; + TIFFHeaderBig big; + } tif_header; + uint16 tif_header_size; /* file's header block and its length */ + uint32 tif_row; /* current scanline */ + uint16 tif_curdir; /* current directory (index) */ + uint32 tif_curstrip; /* current strip for read/write */ + uint64 tif_curoff; /* current offset for read/write */ + uint64 tif_dataoff; /* current offset for writing dir */ + /* SubIFD support */ + uint16 tif_nsubifd; /* remaining subifds to write */ + uint64 tif_subifdoff; /* offset for patching SubIFD link */ + /* tiling support */ + uint32 tif_col; /* current column (offset by row too) */ + uint32 tif_curtile; /* current tile for read/write */ + tmsize_t tif_tilesize; /* # of bytes in a tile */ + /* compression scheme hooks */ + int tif_decodestatus; + TIFFBoolMethod tif_fixuptags; /* called in TIFFReadDirectory */ + TIFFBoolMethod tif_setupdecode; /* called once before predecode */ + TIFFPreMethod tif_predecode; /* pre- row/strip/tile decoding */ + TIFFBoolMethod tif_setupencode; /* called once before preencode */ + int tif_encodestatus; + TIFFPreMethod tif_preencode; /* pre- row/strip/tile encoding */ + TIFFBoolMethod tif_postencode; /* post- row/strip/tile encoding */ + TIFFCodeMethod tif_decoderow; /* scanline decoding routine */ + TIFFCodeMethod tif_encoderow; /* scanline encoding routine */ + TIFFCodeMethod tif_decodestrip; /* strip decoding routine */ + TIFFCodeMethod tif_encodestrip; /* strip encoding routine */ + TIFFCodeMethod tif_decodetile; /* tile decoding routine */ + TIFFCodeMethod tif_encodetile; /* tile encoding routine */ + TIFFVoidMethod tif_close; /* cleanup-on-close routine */ + TIFFSeekMethod tif_seek; /* position within a strip routine */ + TIFFVoidMethod tif_cleanup; /* cleanup state routine */ + TIFFStripMethod tif_defstripsize; /* calculate/constrain strip size */ + TIFFTileMethod tif_deftilesize; /* calculate/constrain tile size */ + uint8* tif_data; /* compression scheme private data */ + /* input/output buffering */ + tmsize_t tif_scanlinesize; /* # of bytes in a scanline */ + tmsize_t tif_scanlineskew; /* scanline skew for reading strips */ + uint8* tif_rawdata; /* raw data buffer */ + tmsize_t tif_rawdatasize; /* # of bytes in raw data buffer */ + tmsize_t tif_rawdataoff; /* rawdata offset within strip */ + tmsize_t tif_rawdataloaded;/* amount of data in rawdata */ + uint8* tif_rawcp; /* current spot in raw buffer */ + tmsize_t tif_rawcc; /* bytes unread from raw buffer */ + /* memory-mapped file support */ + uint8* tif_base; /* base of mapped file */ + tmsize_t tif_size; /* size of mapped file region (bytes, thus tmsize_t) */ + TIFFMapFileProc tif_mapproc; /* map file method */ + TIFFUnmapFileProc tif_unmapproc; /* unmap file method */ + /* input/output callback methods */ + thandle_t tif_clientdata; /* callback parameter */ + TIFFReadWriteProc tif_readproc; /* read method */ + TIFFReadWriteProc tif_writeproc; /* write method */ + TIFFSeekProc tif_seekproc; /* lseek method */ + TIFFCloseProc tif_closeproc; /* close method */ + TIFFSizeProc tif_sizeproc; /* filesize method */ + /* post-decoding support */ + TIFFPostMethod tif_postdecode; /* post decoding routine */ + /* tag support */ + TIFFField** tif_fields; /* sorted table of registered tags */ + size_t tif_nfields; /* # entries in registered tag table */ + const TIFFField* tif_foundfield; /* cached pointer to already found tag */ + TIFFTagMethods tif_tagmethods; /* tag get/set/print routines */ + TIFFClientInfoLink* tif_clientinfo; /* extra client information. */ + /* Backward compatibility stuff. We need these two fields for + * setting up an old tag extension scheme. */ + TIFFFieldArray* tif_fieldscompat; + size_t tif_nfieldscompat; }; -#define isPseudoTag(t) (t > 0xffff) /* is tag value normal or pseudo */ - -#define isTiled(tif) (((tif)->tif_flags & TIFF_ISTILED) != 0) -#define isMapped(tif) (((tif)->tif_flags & TIFF_MAPPED) != 0) -#define isFillOrder(tif, o) (((tif)->tif_flags & (o)) != 0) -#define isUpSampled(tif) (((tif)->tif_flags & TIFF_UPSAMPLED) != 0) -#define TIFFReadFile(tif, buf, size) \ - ((*(tif)->tif_readproc)((tif)->tif_clientdata,buf,size)) -#define TIFFWriteFile(tif, buf, size) \ - ((*(tif)->tif_writeproc)((tif)->tif_clientdata,buf,size)) -#define TIFFSeekFile(tif, off, whence) \ - ((*(tif)->tif_seekproc)((tif)->tif_clientdata,(toff_t)(off),whence)) -#define TIFFCloseFile(tif) \ +#define isPseudoTag(t) (t > 0xffff) /* is tag value normal or pseudo */ + +#define isTiled(tif) (((tif)->tif_flags & TIFF_ISTILED) != 0) +#define isMapped(tif) (((tif)->tif_flags & TIFF_MAPPED) != 0) +#define isFillOrder(tif, o) (((tif)->tif_flags & (o)) != 0) +#define isUpSampled(tif) (((tif)->tif_flags & TIFF_UPSAMPLED) != 0) +#define TIFFReadFile(tif, buf, size) \ + ((*(tif)->tif_readproc)((tif)->tif_clientdata,(buf),(size))) +#define TIFFWriteFile(tif, buf, size) \ + ((*(tif)->tif_writeproc)((tif)->tif_clientdata,(buf),(size))) +#define TIFFSeekFile(tif, off, whence) \ + ((*(tif)->tif_seekproc)((tif)->tif_clientdata,(off),(whence))) +#define TIFFCloseFile(tif) \ ((*(tif)->tif_closeproc)((tif)->tif_clientdata)) -#define TIFFGetFileSize(tif) \ +#define TIFFGetFileSize(tif) \ ((*(tif)->tif_sizeproc)((tif)->tif_clientdata)) -#define TIFFMapFileContents(tif, paddr, psize) \ - ((*(tif)->tif_mapproc)((tif)->tif_clientdata,paddr,psize)) -#define TIFFUnmapFileContents(tif, addr, size) \ - ((*(tif)->tif_unmapproc)((tif)->tif_clientdata,addr,size)) +#define TIFFMapFileContents(tif, paddr, psize) \ + ((*(tif)->tif_mapproc)((tif)->tif_clientdata,(paddr),(psize))) +#define TIFFUnmapFileContents(tif, addr, size) \ + ((*(tif)->tif_unmapproc)((tif)->tif_clientdata,(addr),(size))) /* * Default Read/Seek/Write definitions. */ #ifndef ReadOK -#define ReadOK(tif, buf, size) \ - (TIFFReadFile(tif, (tdata_t) buf, (tsize_t)(size)) == (tsize_t)(size)) +#define ReadOK(tif, buf, size) \ + (TIFFReadFile((tif),(buf),(size))==(size)) #endif #ifndef SeekOK -#define SeekOK(tif, off) \ - (TIFFSeekFile(tif, (toff_t) off, SEEK_SET) == (toff_t) off) +#define SeekOK(tif, off) \ + (TIFFSeekFile((tif),(off),SEEK_SET)==(off)) #endif #ifndef WriteOK -#define WriteOK(tif, buf, size) \ - (TIFFWriteFile(tif, (tdata_t) buf, (tsize_t) size) == (tsize_t) size) +#define WriteOK(tif, buf, size) \ + (TIFFWriteFile((tif),(buf),(size))==(size)) #endif /* NB: the uint32 casts are to silence certain ANSI-C compilers */ -#define TIFFhowmany(x, y) ((((uint32)(x))+(((uint32)(y))-1))/((uint32)(y))) -#define TIFFhowmany8(x) (((x)&0x07)?((uint32)(x)>>3)+1:(uint32)(x)>>3) -#define TIFFroundup(x, y) (TIFFhowmany(x,y)*(y)) +#define TIFFhowmany_32(x, y) (((uint32)x < (0xffffffff - (uint32)(y-1))) ? \ + ((((uint32)(x))+(((uint32)(y))-1))/((uint32)(y))) : \ + 0U) +#define TIFFhowmany8_32(x) (((x)&0x07)?((uint32)(x)>>3)+1:(uint32)(x)>>3) +#define TIFFroundup_32(x, y) (TIFFhowmany_32(x,y)*(y)) +#define TIFFhowmany_64(x, y) ((((uint64)(x))+(((uint64)(y))-1))/((uint64)(y))) +#define TIFFhowmany8_64(x) (((x)&0x07)?((uint64)(x)>>3)+1:(uint64)(x)>>3) +#define TIFFroundup_64(x, y) (TIFFhowmany_64(x,y)*(y)) + +/* Safe multiply which returns zero if there is an integer overflow */ +#define TIFFSafeMultiply(t,v,m) ((((t)(m) != (t)0) && (((t)(((v)*(m))/(m))) == (t)(v))) ? (t)((v)*(m)) : (t)0) #define TIFFmax(A,B) ((A)>(B)?(A):(B)) #define TIFFmin(A,B) ((A)<(B)?(A):(B)) @@ -253,86 +265,95 @@ struct tiff { #if defined(__cplusplus) extern "C" { #endif -extern int _TIFFgetMode(const char*, const char*); -extern int _TIFFNoRowEncode(TIFF*, tidata_t, tsize_t, tsample_t); -extern int _TIFFNoStripEncode(TIFF*, tidata_t, tsize_t, tsample_t); -extern int _TIFFNoTileEncode(TIFF*, tidata_t, tsize_t, tsample_t); -extern int _TIFFNoRowDecode(TIFF*, tidata_t, tsize_t, tsample_t); -extern int _TIFFNoStripDecode(TIFF*, tidata_t, tsize_t, tsample_t); -extern int _TIFFNoTileDecode(TIFF*, tidata_t, tsize_t, tsample_t); -extern void _TIFFNoPostDecode(TIFF*, tidata_t, tsize_t); -extern int _TIFFNoPreCode (TIFF*, tsample_t); -extern int _TIFFNoSeek(TIFF*, uint32); -extern void _TIFFSwab16BitData(TIFF*, tidata_t, tsize_t); -extern void _TIFFSwab24BitData(TIFF*, tidata_t, tsize_t); -extern void _TIFFSwab32BitData(TIFF*, tidata_t, tsize_t); -extern void _TIFFSwab64BitData(TIFF*, tidata_t, tsize_t); -extern int TIFFFlushData1(TIFF*); -extern int TIFFDefaultDirectory(TIFF*); -extern void _TIFFSetDefaultCompressionState(TIFF*); -extern int TIFFSetCompressionScheme(TIFF*, int); -extern int TIFFSetDefaultCompressionState(TIFF*); -extern uint32 _TIFFDefaultStripSize(TIFF*, uint32); -extern void _TIFFDefaultTileSize(TIFF*, uint32*, uint32*); -extern int _TIFFDataSize(TIFFDataType); - -extern void _TIFFsetByteArray(void**, void*, uint32); -extern void _TIFFsetString(char**, char*); -extern void _TIFFsetShortArray(uint16**, uint16*, uint32); -extern void _TIFFsetLongArray(uint32**, uint32*, uint32); -extern void _TIFFsetFloatArray(float**, float*, uint32); -extern void _TIFFsetDoubleArray(double**, double*, uint32); - -extern void _TIFFprintAscii(FILE*, const char*); -extern void _TIFFprintAsciiTag(FILE*, const char*, const char*); - -extern TIFFErrorHandler _TIFFwarningHandler; -extern TIFFErrorHandler _TIFFerrorHandler; -extern TIFFErrorHandlerExt _TIFFwarningHandlerExt; -extern TIFFErrorHandlerExt _TIFFerrorHandlerExt; - -extern tdata_t _TIFFCheckMalloc(TIFF*, size_t, size_t, const char*); -extern tdata_t _TIFFCheckRealloc(TIFF*, tdata_t, size_t, size_t, const char*); - -extern int TIFFInitDumpMode(TIFF*, int); +extern int _TIFFgetMode(const char* mode, const char* module); +extern int _TIFFNoRowEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s); +extern int _TIFFNoStripEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s); +extern int _TIFFNoTileEncode(TIFF*, uint8* pp, tmsize_t cc, uint16 s); +extern int _TIFFNoRowDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s); +extern int _TIFFNoStripDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s); +extern int _TIFFNoTileDecode(TIFF*, uint8* pp, tmsize_t cc, uint16 s); +extern void _TIFFNoPostDecode(TIFF* tif, uint8* buf, tmsize_t cc); +extern int _TIFFNoPreCode(TIFF* tif, uint16 s); +extern int _TIFFNoSeek(TIFF* tif, uint32 off); +extern void _TIFFSwab16BitData(TIFF* tif, uint8* buf, tmsize_t cc); +extern void _TIFFSwab24BitData(TIFF* tif, uint8* buf, tmsize_t cc); +extern void _TIFFSwab32BitData(TIFF* tif, uint8* buf, tmsize_t cc); +extern void _TIFFSwab64BitData(TIFF* tif, uint8* buf, tmsize_t cc); +extern int TIFFFlushData1(TIFF* tif); +extern int TIFFDefaultDirectory(TIFF* tif); +extern void _TIFFSetDefaultCompressionState(TIFF* tif); +extern int _TIFFRewriteField(TIFF *, uint16, TIFFDataType, tmsize_t, void *); +extern int TIFFSetCompressionScheme(TIFF* tif, int scheme); +extern int TIFFSetDefaultCompressionState(TIFF* tif); +extern uint32 _TIFFDefaultStripSize(TIFF* tif, uint32 s); +extern void _TIFFDefaultTileSize(TIFF* tif, uint32* tw, uint32* th); +extern int _TIFFDataSize(TIFFDataType type); + +extern void _TIFFsetByteArray(void**, void*, uint32); +extern void _TIFFsetString(char**, char*); +extern void _TIFFsetShortArray(uint16**, uint16*, uint32); +extern void _TIFFsetLongArray(uint32**, uint32*, uint32); +extern void _TIFFsetFloatArray(float**, float*, uint32); +extern void _TIFFsetDoubleArray(double**, double*, uint32); + +extern void _TIFFprintAscii(FILE*, const char*); +extern void _TIFFprintAsciiTag(FILE*, const char*, const char*); + +extern TIFFErrorHandler _TIFFwarningHandler; +extern TIFFErrorHandler _TIFFerrorHandler; +extern TIFFErrorHandlerExt _TIFFwarningHandlerExt; +extern TIFFErrorHandlerExt _TIFFerrorHandlerExt; + +extern uint32 _TIFFMultiply32(TIFF*, uint32, uint32, const char*); +extern uint64 _TIFFMultiply64(TIFF*, uint64, uint64, const char*); +extern void* _TIFFCheckMalloc(TIFF*, tmsize_t, tmsize_t, const char*); +extern void* _TIFFCheckRealloc(TIFF*, void*, tmsize_t, tmsize_t, const char*); + +extern double _TIFFUInt64ToDouble(uint64); +extern float _TIFFUInt64ToFloat(uint64); + +extern int TIFFInitDumpMode(TIFF*, int); #ifdef PACKBITS_SUPPORT -extern int TIFFInitPackBits(TIFF*, int); +extern int TIFFInitPackBits(TIFF*, int); #endif #ifdef CCITT_SUPPORT -extern int TIFFInitCCITTRLE(TIFF*, int), TIFFInitCCITTRLEW(TIFF*, int); -extern int TIFFInitCCITTFax3(TIFF*, int), TIFFInitCCITTFax4(TIFF*, int); +extern int TIFFInitCCITTRLE(TIFF*, int), TIFFInitCCITTRLEW(TIFF*, int); +extern int TIFFInitCCITTFax3(TIFF*, int), TIFFInitCCITTFax4(TIFF*, int); #endif #ifdef THUNDER_SUPPORT -extern int TIFFInitThunderScan(TIFF*, int); +extern int TIFFInitThunderScan(TIFF*, int); #endif #ifdef NEXT_SUPPORT -extern int TIFFInitNeXT(TIFF*, int); +extern int TIFFInitNeXT(TIFF*, int); #endif #ifdef LZW_SUPPORT -extern int TIFFInitLZW(TIFF*, int); +extern int TIFFInitLZW(TIFF*, int); #endif #ifdef OJPEG_SUPPORT -extern int TIFFInitOJPEG(TIFF*, int); +extern int TIFFInitOJPEG(TIFF*, int); #endif #ifdef JPEG_SUPPORT -extern int TIFFInitJPEG(TIFF*, int); +extern int TIFFInitJPEG(TIFF*, int); #endif #ifdef JBIG_SUPPORT -extern int TIFFInitJBIG(TIFF*, int); +extern int TIFFInitJBIG(TIFF*, int); #endif #ifdef ZIP_SUPPORT -extern int TIFFInitZIP(TIFF*, int); +extern int TIFFInitZIP(TIFF*, int); #endif #ifdef PIXARLOG_SUPPORT -extern int TIFFInitPixarLog(TIFF*, int); +extern int TIFFInitPixarLog(TIFF*, int); #endif #ifdef LOGLUV_SUPPORT -extern int TIFFInitSGILog(TIFF*, int); +extern int TIFFInitSGILog(TIFF*, int); +#endif +#ifdef LZMA_SUPPORT +extern int TIFFInitLZMA(TIFF*, int); #endif #ifdef VMS -extern const TIFFCodec _TIFFBuiltinCODECS[]; +extern const TIFFCodec _TIFFBuiltinCODECS[]; #else -extern TIFFCodec _TIFFBuiltinCODECS[]; +extern TIFFCodec _TIFFBuiltinCODECS[]; #endif #if defined(__cplusplus) @@ -341,3 +362,10 @@ extern TIFFCodec _TIFFBuiltinCODECS[]; #endif /* _TIFFIOP_ */ /* vim: set ts=8 sts=8 sw=8 noet: */ +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/libtiff/tiffvers.h b/src/3rdparty/libtiff/libtiff/tiffvers.h index 7108541..40edc81 100644 --- a/src/3rdparty/libtiff/libtiff/tiffvers.h +++ b/src/3rdparty/libtiff/libtiff/tiffvers.h @@ -1,4 +1,4 @@ -#define TIFFLIB_VERSION_STR "LIBTIFF, Version 3.9.2\nCopyright (c) 1988-1996 Sam Leffler\nCopyright (c) 1991-1996 Silicon Graphics, Inc." +#define TIFFLIB_VERSION_STR "LIBTIFF, Version 4.0.3\nCopyright (c) 1988-1996 Sam Leffler\nCopyright (c) 1991-1996 Silicon Graphics, Inc." /* * This define can be used in code that requires * compilation-related definitions specific to a @@ -6,4 +6,4 @@ * version checking should be done based on the * string returned by TIFFGetVersion. */ -#define TIFFLIB_VERSION 20091104 +#define TIFFLIB_VERSION 20120922 diff --git a/src/3rdparty/libtiff/libtiff/uvcode.h b/src/3rdparty/libtiff/libtiff/uvcode.h index 5b2d7d7..50f11d7 100644 --- a/src/3rdparty/libtiff/libtiff/uvcode.h +++ b/src/3rdparty/libtiff/libtiff/uvcode.h @@ -171,3 +171,10 @@ static struct { { (float)0.016994, 31, 16237 }, { (float)0.023659, 21, 16268 }, }; +/* + * Local Variables: + * mode: c + * c-basic-offset: 8 + * fill-column: 78 + * End: + */ diff --git a/src/3rdparty/libtiff/nmake.opt b/src/3rdparty/libtiff/nmake.opt deleted file mode 100644 index 7e882d2..0000000 --- a/src/3rdparty/libtiff/nmake.opt +++ /dev/null @@ -1,218 +0,0 @@ -# $Id: nmake.opt,v 1.18 2006/06/07 16:33:45 dron Exp $
-#
-# Copyright (C) 2004, Andrey Kiselev <dron@ak4719.spb.edu>
-#
-# 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.
-
-# Compile time parameters for MS Visual C++ compiler.
-# You may edit this file to specify building options.
-
-#
-###### Edit the following lines to choose a feature set you need. #######
-#
-
-#
-# Select WINMODE_CONSOLE to build a library which reports errors to stderr, or
-# WINMODE_WINDOWED to build such that errors are reported via MessageBox().
-#
-WINMODE_CONSOLE = 1
-#WINMODE_WINDOWED = 1
-
-#
-# Comment out the following lines to disable internal codecs.
-#
-# Support for CCITT Group 3 & 4 algorithms
-CCITT_SUPPORT = 1
-# Support for Macintosh PackBits algorithm
-PACKBITS_SUPPORT = 1
-# Support for LZW algorithm
-LZW_SUPPORT = 1
-# Support for ThunderScan 4-bit RLE algorithm
-THUNDER_SUPPORT = 1
-# Support for NeXT 2-bit RLE algorithm
-NEXT_SUPPORT = 1
-# Support for LogLuv high dynamic range encoding
-LOGLUV_SUPPORT = 1
-
-#
-# Uncomment and edit following lines to enable JPEG support.
-#
-#JPEG_SUPPORT = 1
-#JPEGDIR = d:/projects/jpeg-6b
-#JPEG_INCLUDE = -I$(JPEGDIR)
-#JPEG_LIB = $(JPEGDIR)/Release/jpeg.lib
-
-#
-# Uncomment and edit following lines to enable ZIP support
-# (required for Deflate compression and Pixar log-format)
-#
-#ZIP_SUPPORT = 1
-#ZLIBDIR = d:/projects/zlib-1.2.1
-#ZLIB_INCLUDE = -I$(ZLIBDIR)
-#ZLIB_LIB = $(ZLIBDIR)/zlib.lib
-
-#
-# Uncomment and edit following lines to enable ISO JBIG support
-#
-#JBIG_SUPPORT = 1
-#JBIGDIR = d:/projects/jbigkit
-#JBIG_INCLUDE = -I$(JBIGDIR)/libjbig
-#JBIG_LIB = $(JBIGDIR)/libjbig/jbig.lib
-
-#
-# Uncomment following line to enable Pixar log-format algorithm
-# (Zlib required).
-#
-#PIXARLOG_SUPPORT = 1
-
-#
-# Comment out the following lines to disable strip chopping
-# (whether or not to convert single-strip uncompressed images to mutiple
-# strips of specified size to reduce memory usage). Default strip size
-# is 8192 bytes, it can be configured via the STRIP_SIZE_DEFAULT parameter
-#
-STRIPCHOP_SUPPORT = 1
-STRIP_SIZE_DEFAULT = 8192
-
-#
-# Comment out the following lines to disable treating the fourth sample with
-# no EXTRASAMPLE_ value as being ASSOCALPHA. Many packages produce RGBA
-# files but don't mark the alpha properly.
-#
-EXTRASAMPLE_AS_ALPHA_SUPPORT = 1
-
-#
-# Comment out the following lines to disable picking up YCbCr subsampling
-# info from the JPEG data stream to support files lacking the tag.
-# See Bug 168 in Bugzilla, and JPEGFixupTestSubsampling() for details.
-#
-CHECK_JPEG_YCBCR_SUBSAMPLING = 1
-
-#
-####################### Compiler related options. #######################
-#
-
-#
-# Pick debug or optimized build flags. We default to an optimized build
-# with no debugging information.
-# NOTE: /EHsc option required if you want to build the C++ stream API
-#
-OPTFLAGS = /Ox /MD /EHsc /W3 /D_CRT_SECURE_NO_DEPRECATE
-#OPTFLAGS = /Zi
-
-#
-# Uncomment following line to enable using Windows Common RunTime Library
-# instead of Windows specific system calls. See notes on top of tif_unix.c
-# module for details.
-#
-USE_WIN_CRT_LIB = 1
-
-# Compiler specific options. You may probably want to adjust compilation
-# parameters in CFLAGS variable. Refer to your compiler documentation
-# for the option reference.
-#
-MAKE = nmake /nologo
-CC = cl /nologo
-CXX = cl /nologo
-AR = lib /nologo
-LD = link /nologo
-
-CFLAGS = $(OPTFLAGS) $(INCL) $(EXTRAFLAGS)
-CXXFLAGS = $(OPTFLAGS) $(INCL) $(EXTRAFLAGS)
-EXTRAFLAGS =
-LIBS =
-
-# Name of the output shared library
-DLLNAME = libtiff.dll
-
-#
-########### There is nothing to edit below this line normally. ###########
-#
-
-# Set the native cpu bit order
-EXTRAFLAGS = -DFILLODER_LSB2MSB $(EXTRAFLAGS)
-
-!IFDEF WINMODE_WINDOWED
-EXTRAFLAGS = -DTIF_PLATFORM_WINDOWED $(EXTRAFLAGS)
-LIBS = user32.lib $(LIBS)
-!ELSE
-EXTRAFLAGS = -DTIF_PLATFORM_CONSOLE $(EXTRAFLAGS)
-!ENDIF
-
-# Codec stuff
-!IFDEF CCITT_SUPPORT
-EXTRAFLAGS = -DCCITT_SUPPORT $(EXTRAFLAGS)
-!ENDIF
-
-!IFDEF PACKBITS_SUPPORT
-EXTRAFLAGS = -DPACKBITS_SUPPORT $(EXTRAFLAGS)
-!ENDIF
-
-!IFDEF LZW_SUPPORT
-EXTRAFLAGS = -DLZW_SUPPORT $(EXTRAFLAGS)
-!ENDIF
-
-!IFDEF THUNDER_SUPPORT
-EXTRAFLAGS = -DTHUNDER_SUPPORT $(EXTRAFLAGS)
-!ENDIF
-
-!IFDEF NEXT_SUPPORT
-EXTRAFLAGS = -DNEXT_SUPPORT $(EXTRAFLAGS)
-!ENDIF
-
-!IFDEF LOGLUV_SUPPORT
-EXTRAFLAGS = -DLOGLUV_SUPPORT $(EXTRAFLAGS)
-!ENDIF
-
-!IFDEF JPEG_SUPPORT
-LIBS = $(LIBS) $(JPEG_LIB)
-EXTRAFLAGS = -DJPEG_SUPPORT -DOJPEG_SUPPORT $(EXTRAFLAGS)
-!ENDIF
-
-!IFDEF ZIP_SUPPORT
-LIBS = $(LIBS) $(ZLIB_LIB)
-EXTRAFLAGS = -DZIP_SUPPORT $(EXTRAFLAGS)
-!IFDEF PIXARLOG_SUPPORT
-EXTRAFLAGS = -DPIXARLOG_SUPPORT $(EXTRAFLAGS)
-!ENDIF
-!ENDIF
-
-!IFDEF JBIG_SUPPORT
-LIBS = $(LIBS) $(JBIG_LIB)
-EXTRAFLAGS = -DJBIG_SUPPORT $(EXTRAFLAGS)
-!ENDIF
-
-!IFDEF STRIPCHOP_SUPPORT
-EXTRAFLAGS = -DSTRIPCHOP_DEFAULT=TIFF_STRIPCHOP -DSTRIP_SIZE_DEFAULT=$(STRIP_SIZE_DEFAULT) $(EXTRAFLAGS)
-!ENDIF
-
-!IFDEF EXTRASAMPLE_AS_ALPHA_SUPPORT
-EXTRAFLAGS = -DDEFAULT_EXTRASAMPLE_AS_ALPHA $(EXTRAFLAGS)
-!ENDIF
-
-!IFDEF CHECK_JPEG_YCBCR_SUBSAMPLING
-EXTRAFLAGS = -DCHECK_JPEG_YCBCR_SUBSAMPLING $(EXTRAFLAGS)
-!ENDIF
-
-!IFDEF USE_WIN_CRT_LIB
-EXTRAFLAGS = -DAVOID_WIN32_FILEIO $(EXTRAFLAGS)
-!ELSE
-EXTRAFLAGS = -DUSE_WIN32_FILEIO $(EXTRAFLAGS)
-!ENDIF
diff --git a/src/3rdparty/libtiff/port/dummy.c b/src/3rdparty/libtiff/port/dummy.c index 1cbda6a..46f93bc 100644 --- a/src/3rdparty/libtiff/port/dummy.c +++ b/src/3rdparty/libtiff/port/dummy.c @@ -1,4 +1,4 @@ -/* $Id: dummy.c,v 1.2.2.1 2007/03/21 14:53:46 dron Exp $ */ +/* $Id: dummy.c,v 1.3 2007/03/21 14:54:16 dron Exp $ */ /* * Dummy function, just to be ensure that the library always will be created. diff --git a/src/3rdparty/libtiff/port/getopt.c b/src/3rdparty/libtiff/port/getopt.c index 0138c89..6eff8ee 100644 --- a/src/3rdparty/libtiff/port/getopt.c +++ b/src/3rdparty/libtiff/port/getopt.c @@ -1,4 +1,4 @@ -/* $Id: getopt.c,v 1.2 2005/07/07 16:34:06 dron Exp $ */ +/* $Id: getopt.c,v 1.3 2009-01-22 20:53:07 fwarmerdam Exp $ */ /* * Copyright (c) 1987, 1993, 1994 @@ -36,6 +36,7 @@ __RCSID("$NetBSD: getopt.c,v 1.26 2003/08/07 16:43:40 agc Exp $"); #include <stdio.h> #include <string.h> +#include "libport.h" int opterr = 1, /* if error message should be printed */ optind = 1, /* index into parent argv vector */ diff --git a/src/3rdparty/libtiff/port/libport.h b/src/3rdparty/libtiff/port/libport.h index e3413f7..802f478 100644 --- a/src/3rdparty/libtiff/port/libport.h +++ b/src/3rdparty/libtiff/port/libport.h @@ -1,4 +1,4 @@ -/* $Id: libport.h,v 1.2.2.2 2009-11-02 14:47:41 bfriesen Exp $ */ +/* $Id: libport.h,v 1.2 2009-11-02 14:44:13 bfriesen Exp $ */ /* * Copyright (c) 2009 Frank Warmerdam diff --git a/src/3rdparty/libtiff/port/strcasecmp.c b/src/3rdparty/libtiff/port/strcasecmp.c index 2422304..1ff4312 100644 --- a/src/3rdparty/libtiff/port/strcasecmp.c +++ b/src/3rdparty/libtiff/port/strcasecmp.c @@ -1,4 +1,4 @@ -/* $Id: strcasecmp.c,v 1.2 2005/07/07 16:34:06 dron Exp $ */ +/* $Id: strcasecmp.c,v 1.3 2009-01-22 20:53:07 fwarmerdam Exp $ */ /* * Copyright (c) 1987, 1993 @@ -36,6 +36,7 @@ __RCSID("$NetBSD: strcasecmp.c,v 1.16 2003/08/07 16:43:49 agc Exp $"); #include <ctype.h> #include <string.h> +#include "libport.h" int strcasecmp(const char *s1, const char *s2) |
