AuroraMiddleware/qt5base-lts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Moving tiff image format support and libtiff out of qtbase

Browse Source 
The tiff plugin and bundled libtiff is moving to the qtimageformats
project on Gerrit.

Task-number: QTBUG-23887
Change-Id: I4c848232fdccddd7e7f54215f9eaa78dc4c3a53d
Reviewed-by: Kent Hansen <kent.hansen@nokia.com>
Reviewed-by: Lars Knoll <lars.knoll@nokia.com>
This commit is contained in:
aavit 2012-01-25 16:04:51 +01:00 committed by Qt by Nokia
parent bf9bdf5328
commit 4fce5d1795
284 changed files with 24 additions and 71076 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
config.tests/unix/libtiff/libtiff.cpp
View File

@ -1,65 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/
**
** This file is part of the config.tests of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** GNU Lesser General Public License Usage
** This file may be used under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation and
** appearing in the file LICENSE.LGPL included in the packaging of this
** file. Please review the following information to ensure the GNU Lesser
** General Public License version 2.1 requirements will be met:
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU General
** Public License version 3.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of this
** file. Please review the following information to ensure the GNU General
** Public License version 3.0 requirements will be met:
** http://www.gnu.org/copyleft/gpl.html.
**
** Other Usage
** Alternatively, this file may be used in accordance with the terms and
** conditions contained in a signed written agreement between you and Nokia.
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <tiffio.h>
#if !defined(TIFF_VERSION) && defined(TIFF_VERSION_CLASSIC)
// libtiff 4.0 splits it into TIFF_VERSION_CLASSIC and TIFF_VERSION_BIG
# define TIFF_VERSION TIFF_VERSION_CLASSIC
#endif
#if !defined(TIFF_VERSION)
# error "Required libtiff not found"
#elif TIFF_VERSION < 42
# error "unsupported tiff version"
#endif
int main(int, char **)
{
tdata_t buffer = _TIFFmalloc(128);
_TIFFfree(buffer);
// some libtiff implementations where TIFF_VERSION >= 42 do not
// have TIFFReadRGBAImageOriented(), so let's check for it
TIFFReadRGBAImageOriented(0, 0, 0, 0, 0, 0);
return 0;
}

4
config.tests/unix/libtiff/libtiff.pro
View File

@ -1,4 +0,0 @@
SOURCES = libtiff.cpp
CONFIG -= qt dylib
mac:CONFIG -= app_bundle
LIBS += -ltiff

53
configure vendored
View File

@ -657,8 +657,6 @@ CFG_XFIXES=runtime
CFG_ZLIB=auto
CFG_SQLITE=qt
CFG_GIF=auto
CFG_TIFF=auto
CFG_LIBTIFF=auto
CFG_PNG=yes
CFG_LIBPNG=auto
CFG_JPEG=auto
@ -940,7 +938,6 @@ if [ "$CFG_EMBEDDED" = "nacl" ]; then
CFG_MEDIASERVICES=no
CFG_SQLITE=no
CFG_SQL_sqlite=no
CFG_LIBTIFF=no
CFG_NOBUILD_PARTS="$CFG_NOBUILD_PARTS tests"
QT_CONFIG="$QT_CONFIG nacl"
fi
@ -1776,14 +1773,6 @@ while [ "$#" -gt 0 ]; do
UNKNOWN_OPT=yes
fi
;;
libtiff)
[ "$VAL" = "yes" ] && VAL=qt
if [ "$VAL" = "qt" ] || [ "$VAL" = "no" ] || [ "$VAL" = "system" ]; then
CFG_LIBTIFF="$VAL"
else
UNKNOWN_OPT=yes
fi
;;
nas-sound)
if [ "$VAL" = "system" ] || [ "$VAL" = "no" ]; then
CFG_NAS="$VAL"
@ -3419,8 +3408,7 @@ Usage: $relconf [-h] [-prefix <dir>] [-prefix-install] [-bindir <dir>] [-libdir
[-accessibility] [-no-stl] [-stl] [-no-sql-<driver>] [-sql-<driver>]
[-plugin-sql-<driver>] [-system-sqlite]
[-platform] [-D <string>] [-I <string>] [-L <string>] [-help]
[-qt-zlib] [-system-zlib] [-no-gif] [-no-libtiff] [-qt-libtiff] [-system-libtiff]
[-no-libpng] [-qt-libpng] [-system-libpng]
[-qt-zlib] [-system-zlib] [-no-gif] [-no-libpng] [-qt-libpng] [-system-libpng]
[-no-libjpeg] [-qt-libjpeg] [-system-libjpeg] [-make <part>]
[-nomake <part>] [-R <string>] [-l <string>] [-no-rpath] [-rpath] [-continue]
[-verbose] [-v] [-silent] [-no-nis] [-nis] [-no-cups] [-cups] [-no-iconv]
@ -3615,11 +3603,6 @@ Third Party Libraries:
-no-gif ............ Do not compile GIF reading support.
-no-libtiff ........ Do not compile TIFF support.
-qt-libtiff ........ Use the libtiff bundled with Qt.
+ -system-libtiff .... Use libtiff from the operating system.
See http://www.libtiff.org
-no-libpng ......... Do not compile PNG support.
-qt-libpng ......... Use the libpng bundled with Qt.
+ -system-libpng ..... Use libpng from the operating system.
@ -4760,24 +4743,6 @@ if [ "$CFG_GIF" = "auto" ]; then
fi
fi
# detect how tiff should be built
if [ "$CFG_TIFF" = "auto" ]; then
if [ "$CFG_SHARED" = "yes" ]; then
CFG_TIFF=plugin
else
CFG_TIFF=yes
fi
fi
# detect tiff
if [ "$CFG_LIBTIFF" = "auto" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/libtiff "libtiff" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
CFG_LIBTIFF=system
else
CFG_LIBTIFF=qt
fi
fi
# detect png
if [ "$CFG_LIBPNG" = "auto" ]; then
if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/libpng "libpng" $L_FLAGS $I_FLAGS $l_FLAGS $MAC_CONFIG_TEST_COMMANDLINE; then
@ -6539,16 +6504,6 @@ if [ "$CFG_GIF" = "no" ]; then
elif [ "$CFG_GIF" = "yes" ]; then
QT_CONFIG="$QT_CONFIG gif"
fi
if [ "$CFG_LIBTIFF" = "no" ]; then
CFG_TIFF="no"
elif [ "$CFG_LIBTIFF" = "system" ]; then
QT_CONFIG="$QT_CONFIG system-tiff"
fi
if [ "$CFG_TIFF" = "no" ]; then
QT_CONFIG="$QT_CONFIG no-tiff"
elif [ "$CFG_TIFF" = "yes" ]; then
QT_CONFIG="$QT_CONFIG tiff"
fi
if [ "$CFG_LIBFREETYPE" = "no" ]; then
QT_CONFIG="$QT_CONFIG no-freetype"
QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_FREETYPE"
@ -7164,7 +7119,6 @@ QMakeVar set sql-plugins "$SQL_PLUGINS"
# Add other configuration options to the qconfig.h file
[ "$CFG_GIF" = "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_BUILTIN_GIF_READER=1"
[ "$CFG_TIFF" != "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IMAGEFORMAT_TIFF"
[ "$CFG_PNG" != "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IMAGEFORMAT_PNG"
[ "$CFG_JPEG" != "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_IMAGEFORMAT_JPEG"
[ "$CFG_ZLIB" != "yes" ] && QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_ZLIB"
@ -7619,11 +7573,6 @@ echo "GStreamer support ...... $CFG_GSTREAMER"
echo "PulseAudio support ..... $CFG_PULSEAUDIO"
echo "Large File support ..... $CFG_LARGEFILE"
echo "GIF support ............ $CFG_GIF"
if [ "$CFG_TIFF" = "no" ]; then
echo "TIFF support ........... $CFG_TIFF"
else
echo "TIFF support ........... $CFG_TIFF ($CFG_LIBTIFF)"
fi
if [ "$CFG_JPEG" = "no" ]; then
echo "JPEG support ........... $CFG_JPEG"
else

2
examples/itemviews/puzzle/puzzle.pro
View File

@ -15,7 +15,7 @@ INSTALLS += target sources
wince* {
DEPLOYMENT_PLUGIN += qjpeg qgif qtiff
DEPLOYMENT_PLUGIN += qjpeg qgif
}
QT += widgets

2
examples/qtconcurrent/imagescaling/imagescaling.pro
View File

@ -13,7 +13,7 @@ sources.path = $$[QT_INSTALL_EXAMPLES]/qtbase/qtconcurrent/imagescaling
INSTALLS += target sources
wince*: DEPLOYMENT_PLUGIN += qgif qjpeg qtiff
wince*: DEPLOYMENT_PLUGIN += qgif qjpeg
QT += widgets
simulator: warning(This example does not work on Simulator platform)

2
mkspecs/features/qt.prf
View File

@ -61,7 +61,7 @@ for(QT_CURRENT_VERIFY, $$list($$QT_PLUGIN_VERIFY)) {
DECORATIONPLUGINS = qdecorationdefault qdecorationstyled qdecorationwindows
GFXDRIVERPLUGINS = qgfxvnc qscreenvfb qgfxtransformed qgfxshadowfb qgfxpvregl qscreenlinuxfb qeglnullws qdirectfbscreen qahiscreen
GRAPHICSSYSTEMPLUGINS = qmeegographicssystem qglgraphicssystem qvggraphicssystem qshivavggraphicssystem
IMAGEPLUGINS = qgif qico qjpeg qsvg qtiff
IMAGEPLUGINS = qgif qico qjpeg qsvg
INPUTPLUGINS = qimsw-multi
KBDDRIVERPLUGINS = qlinuxinputkbddriver
MOUSEDRIVERPLUGINS = qtslibmousehandler qpcmousedriver qlinuxtpmousedriver

1
src/3rdparty/.gitattributes vendored
View File

@ -11,7 +11,6 @@ libpng/projects/visualc71/libpng.sln -crlf
libpng/projects/visualc71/libpng.vcproj -crlf
libpng/projects/visualc71/pngtest.vcproj -crlf
libpng/projects/visualc71/zlib.vcproj -crlf
libtiff/nmake.opt -crlf
zlib/projects/visualc6/example.dsp -crlf
zlib/projects/visualc6/minigzip.dsp -crlf
zlib/projects/visualc6/README.txt -crlf

43
src/3rdparty/libtiff.pri vendored
View File

@ -1,43 +0,0 @@
INCLUDEPATH += $$PWD/libtiff/libtiff
SOURCES += \
$$PWD/libtiff/libtiff/tif_aux.c \
$$PWD/libtiff/libtiff/tif_close.c \
$$PWD/libtiff/libtiff/tif_codec.c \
$$PWD/libtiff/libtiff/tif_color.c \
$$PWD/libtiff/libtiff/tif_compress.c \
$$PWD/libtiff/libtiff/tif_dir.c \
$$PWD/libtiff/libtiff/tif_dirinfo.c \
$$PWD/libtiff/libtiff/tif_dirread.c \
$$PWD/libtiff/libtiff/tif_dirwrite.c \
$$PWD/libtiff/libtiff/tif_dumpmode.c \
$$PWD/libtiff/libtiff/tif_error.c \
$$PWD/libtiff/libtiff/tif_extension.c \
$$PWD/libtiff/libtiff/tif_fax3.c \
$$PWD/libtiff/libtiff/tif_fax3sm.c \
$$PWD/libtiff/libtiff/tif_flush.c \
$$PWD/libtiff/libtiff/tif_getimage.c \
$$PWD/libtiff/libtiff/tif_luv.c \
$$PWD/libtiff/libtiff/tif_lzw.c \
$$PWD/libtiff/libtiff/tif_next.c \
$$PWD/libtiff/libtiff/tif_open.c \
$$PWD/libtiff/libtiff/tif_packbits.c \
$$PWD/libtiff/libtiff/tif_pixarlog.c \
$$PWD/libtiff/libtiff/tif_predict.c \
$$PWD/libtiff/libtiff/tif_print.c \
$$PWD/libtiff/libtiff/tif_read.c \
$$PWD/libtiff/libtiff/tif_strip.c \
$$PWD/libtiff/libtiff/tif_swab.c \
$$PWD/libtiff/libtiff/tif_thunder.c \
$$PWD/libtiff/libtiff/tif_tile.c \
$$PWD/libtiff/libtiff/tif_version.c \
$$PWD/libtiff/libtiff/tif_warning.c \
$$PWD/libtiff/libtiff/tif_write.c \
$$PWD/libtiff/libtiff/tif_zip.c
wince*: SOURCES += $$PWD/../corelib/kernel/qfunctions_wince.cpp \
$$PWD/libtiff/libtiff/tif_wince.c
win32: SOURCES += $$PWD/libtiff/libtiff/tif_win32.c
else: SOURCES += $$PWD/libtiff/libtiff/tif_unix.c
symbian: SOURCES += $$PWD/libtiff/port/lfind.c
include($$PWD/zlib_dependency.pri)

21
src/3rdparty/libtiff/COPYRIGHT vendored
View File

@ -1,21 +0,0 @@
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.

4426
src/3rdparty/libtiff/ChangeLog vendored
View File

File diff suppressed because it is too large Load Diff

105
src/3rdparty/libtiff/HOWTO-RELEASE vendored
View File

@ -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.

59
src/3rdparty/libtiff/README vendored
View File

@ -1,59 +0,0 @@
$Header: /cvs/maptools/cvsroot/libtiff/README,v 1.5 2004/10/30 13:44:45 dron 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.
netscape 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
ftp://ftp.remotesensing.org/pub/libtiff/
If you can't hack either of these options then basically what you
want to do is:
% ./configure
% make
% su
# make install
More information, email contacts, and mailing list information can be
found online at http://www.remotesensing.org/libtiff/.
Use and Copyright
-----------------
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. I would
also be interested in knowing about it and, hopefully, be acknowledged.
The legal way of saying that is:
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.

12
src/3rdparty/libtiff/README.vms vendored
View File

@ -1,12 +0,0 @@
Dear OpenVMS user
to make this library, execute
$@CONFIGURE
$@BUILD
Build process should be error and warning free. When process will be finished,
LIBTIFF$STRATUP.COM file containing all required definitions, will be created.
Please call it from system startup procedure or individual user procedure LOGIN.COM
To link software with libtiff, use TIFF:LIBTIFF.OPT
best regards,
Alexey Chupahin, elvis_75@mail.ru

1
src/3rdparty/libtiff/RELEASE-DATE vendored
View File

@ -1 +0,0 @@
20091104

171
src/3rdparty/libtiff/SConstruct vendored
View File

@ -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')

12
src/3rdparty/libtiff/TODO vendored
View File

@ -1,12 +0,0 @@
# $Header: /cvs/maptools/cvsroot/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
o YCbCr sampling support
o extracate colorspace conversion support
o look at isolating all codecs from TIFF library
o JPEG colormode order dependency problem
o Write documentation on how do extend tags, and how the custom field
stuff all works.

1
src/3rdparty/libtiff/VERSION vendored
View File

@ -1 +0,0 @@
3.9.2

707
src/3rdparty/libtiff/html/TIFFTechNote2.html vendored
View File

@ -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>

292
src/3rdparty/libtiff/html/addingtags.html vendored
View File

@ -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+&lt;offset&gt;</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>

63
src/3rdparty/libtiff/html/bugs.html vendored
View File

@ -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">&lt;warmerdam@pobox.com&gt;</a>,
Andrey Kiselev
<a href="mailto:dron@ak4719.spb.edu">&lt;dron@ak4719.spb.edu&gt;</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>

880
src/3rdparty/libtiff/html/build.html vendored
View File

@ -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&amp;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]&nbsp;&nbsp;&nbsp;&nbsp;build shared
libraries [default=yes]<br>
--enable-static[=PKGS]&nbsp;&nbsp;&nbsp;&nbsp;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&nbsp;&nbsp;&nbsp;&nbsp;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&nbsp;&nbsp;&nbsp;&nbsp;disable IJG JPEG
library usage (required for JPEG compression, enabled by default)
--with-jpeg-include-dir=DIR&nbsp;&nbsp;&nbsp;&nbsp;location of IJG
JPEG library headers
--with-jpeg-lib-dir=DIR&nbsp;&nbsp;&nbsp;&nbsp;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 &lt;fcntl.h&gt;
... 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&gt; nmake /f makefile.vc clean
C:\tiff-3.7.4&gt; nmake /f makefile.vc
or (the hard way)
C:\tiff-3.7.4&gt; cd port
C:\tiff-3.7.4\port&gt; nmake /f makefile.vc clean
C:\tiff-3.7.4\port&gt; nmake /f makefile.vc
C:\tiff-3.7.4&gt; cd ../libtiff
C:\tiff-3.7.4\libtiff&gt; nmake /f makefile.vc clean
C:\tiff-3.7.4\libtiff&gt; nmake /f makefile.vc
C:\tiff-3.7.4\libtiff&gt; cd ..\tools
C:\tiff-3.7.4\tools&gt; nmake /f makefile.vc clean
C:\tiff-3.7.4\tools&gt; 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 &lt;file&gt;.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
&lt;tiffio.h&gt;"</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 &lt;source_dir&gt; &lt;dest_dir&gt;</tt></p>
<p>Install will then create &lt;dest_dir&gt; 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>

209
src/3rdparty/libtiff/html/contrib.html vendored
View File

@ -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>

48
src/3rdparty/libtiff/html/document.html vendored
View File

@ -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>

41
src/3rdparty/libtiff/html/images.html vendored
View File

@ -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>

BIN
src/3rdparty/libtiff/html/images/back.gif vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1000 B

BIN
src/3rdparty/libtiff/html/images/bali.jpg vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 26 KiB

BIN
src/3rdparty/libtiff/html/images/cat.gif vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 12 KiB

BIN
src/3rdparty/libtiff/html/images/cover.jpg vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 20 KiB

BIN
src/3rdparty/libtiff/html/images/cramps.gif vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 13 KiB

BIN
src/3rdparty/libtiff/html/images/dave.gif vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 8.0 KiB

BIN
src/3rdparty/libtiff/html/images/info.gif vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 131 B

BIN
src/3rdparty/libtiff/html/images/jello.jpg vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 13 KiB

BIN
src/3rdparty/libtiff/html/images/jim.gif vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 14 KiB

BIN
src/3rdparty/libtiff/html/images/note.gif vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 264 B

BIN
src/3rdparty/libtiff/html/images/oxford.gif vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 5.9 KiB

BIN
src/3rdparty/libtiff/html/images/quad.jpg vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 23 KiB

BIN
src/3rdparty/libtiff/html/images/ring.gif vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 4.2 KiB

BIN
src/3rdparty/libtiff/html/images/smallliz.jpg vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 16 KiB

BIN
src/3rdparty/libtiff/html/images/strike.gif vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 5.5 KiB

BIN
src/3rdparty/libtiff/html/images/warning.gif vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 287 B

123
src/3rdparty/libtiff/html/index.html vendored
View File

@ -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 &gt;= 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>

572
src/3rdparty/libtiff/html/internals.html vendored
View File

@ -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>&lt;stdarg.h&gt;</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>&lt;stdarg.h&gt;</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_&lt;os&gt;.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 &gt;0 and &lt;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>

68
src/3rdparty/libtiff/html/intro.html vendored
View File

@ -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>

747
src/3rdparty/libtiff/html/libtiff.html vendored
View File

@ -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 &lt;<i>version</i>&gt; &lt;<i>alpha</i>&gt;</tt>
</p>
<p>
where <tt>&lt;<i>version</i>&gt;</tt> is whatever you get from
<tt>"cat VERSION"</tt> and <tt>&lt;<i>alpha</i>&gt;</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>&lt;tiffio.h&gt;</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>
&nbsp;&nbsp;&nbsp;&nbsp;TIFF* tif = TIFFOpen("foo.tif", "r");<br>
&nbsp;&nbsp;&nbsp;&nbsp;... do stuff ...<br>
&nbsp;&nbsp;&nbsp;&nbsp;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>
&nbsp;&nbsp;&nbsp;&nbsp;TIFF* tif = TIFFOpen("foo.tif", "w");<br>
&nbsp;&nbsp;&nbsp;&nbsp;... do stuff ...<br>
&nbsp;&nbsp;&nbsp;&nbsp;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>
&nbsp;&nbsp;&nbsp;&nbsp;TIFF* tif = TIFFOpen(argv[1], "r");<br>
&nbsp;&nbsp;&nbsp;&nbsp;if (tif) {<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;int dircount = 0;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;do {<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;dircount++;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;} while (TIFFReadDirectory(tif));<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;printf("%d directories in %s\n", dircount, argv[1]);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;TIFFClose(tif);<br>
&nbsp;&nbsp;&nbsp;&nbsp;}<br>
&nbsp;&nbsp;&nbsp;&nbsp;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>
&nbsp;&nbsp;&nbsp;&nbsp;TIFF* tif = TIFFOpen(argv[1], "r");<br>
&nbsp;&nbsp;&nbsp;&nbsp;if (tif) {<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;uint32 w, h;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;size_t npixels;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;uint32* raster;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &amp;w);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &amp;h);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;npixels = w * h;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;raster = (uint32*) _TIFFmalloc(npixels * sizeof (uint32));<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if (raster != NULL) {<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if (TIFFReadRGBAImage(tif, w, h, raster, 0)) {<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;...process raster data...<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;_TIFFfree(raster);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;TIFFClose(tif);<br>
&nbsp;&nbsp;&nbsp;&nbsp;}<br>
&nbsp;&nbsp;&nbsp;&nbsp;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>
&nbsp;&nbsp;&nbsp;&nbsp;TIFF* tif = TIFFOpen(argv[1], "r");<br>
&nbsp;&nbsp;&nbsp;&nbsp;if (tif) {<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;TIFFRGBAImage img;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;char emsg[1024];<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if (TIFFRGBAImageBegin(&amp;img, tif, 0, emsg)) {<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;size_t npixels;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;uint32* raster;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;npixels = img.width * img.height;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;raster = (uint32*) _TIFFmalloc(npixels * sizeof (uint32));<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if (raster != NULL) {<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if (TIFFRGBAImageGet(&amp;img, raster, img.width, img.height)) {<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;...process raster data...<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;_TIFFfree(raster);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;TIFFRGBAImageEnd(&amp;img);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;} else<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;TIFFError(argv[1], emsg);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;TIFFClose(tif);<br>
&nbsp;&nbsp;&nbsp;&nbsp;}<br>
&nbsp;&nbsp;&nbsp;&nbsp;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>
&nbsp;&nbsp;&nbsp;&nbsp;TIFF* tif = TIFFOpen("myfile.tif", "r");<br>
&nbsp;&nbsp;&nbsp;&nbsp;if (tif) {<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;uint32 imagelength;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;tdata_t buf;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;uint32 row;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &amp;imagelength);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;buf = _TIFFmalloc(TIFFScanlineSize(tif));<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;for (row = 0; row &lt; imagelength; row++)<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;tiffreadscanline(tif, buf, row);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;_tifffree(buf);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;tiffclose(tif);<br>
&nbsp;&nbsp;&nbsp;&nbsp;}<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>
&nbsp;&nbsp;&nbsp;&nbsp;TIFF* tif = TIFFOpen("myfile.tif", "r");<br>
&nbsp;&nbsp;&nbsp;&nbsp;if (tif) {<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;uint32 imagelength;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;tdata_t buf;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;uint32 row;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &amp;imagelength);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;TIFFGetField(tif, TIFFTAG_PLANARCONFIG, &amp;config);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;buf = _TIFFmalloc(TIFFScanlineSize(tif));<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if (config == PLANARCONFIG_CONTIG) {<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;for (row = 0; row &lt; imagelength; row++)<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;tiffreadscanline(tif, buf, row);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;} else if (config == planarconfig_separate) {<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;uint16 s, nsamples;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;tiffgetfield(tif, tifftag_samplesperpixel, &amp;nsamples);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;for (s = 0; s &lt; nsamples; s++)<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;for (row = 0; row &lt; imagelength; row++)<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;tiffreadscanline(tif, buf, row, s);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;_tifffree(buf);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;tiffclose(tif);<br>
&nbsp;&nbsp;&nbsp;&nbsp;}<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>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;for (row = 0; row &lt; imagelength; row++)<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;for (s = 0; s &lt; nsamples; s++)<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;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>
&nbsp;&nbsp;&nbsp;&nbsp;TIFF* tif = TIFFOpen("myfile.tif", "r");<br>
&nbsp;&nbsp;&nbsp;&nbsp;if (tif) {<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;tdata_t buf;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;tstrip_t strip;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;buf = _TIFFmalloc(TIFFStripSize(tif));<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;for (strip = 0; strip &lt; tiffnumberofstrips(tif); strip++)<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;tiffreadencodedstrip(tif, strip, buf, (tsize_t) -1);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;_tifffree(buf);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;tiffclose(tif);<br>
&nbsp;&nbsp;&nbsp;&nbsp;}<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>
&nbsp;&nbsp;&nbsp;&nbsp;TIFF* tif = TIFFOpen("myfile.tif", "r");<br>
&nbsp;&nbsp;&nbsp;&nbsp;if (tif) {<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;tdata_t buf;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;tstrip_t strip;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;uint32* bc;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;uint32 stripsize;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;TIFFGetField(tif, TIFFTAG_STRIPBYTECOUNTS, &amp;bc);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;stripsize = bc[0];<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;buf = _TIFFmalloc(stripsize);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;for (strip = 0; strip &lt; tiffnumberofstrips(tif); strip++) {<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if (bc[strip] &gt; stripsize) {<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;buf = _TIFFrealloc(buf, bc[strip]);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;stripsize = bc[strip];<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;TIFFReadRawStrip(tif, strip, buf, bc[strip]);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;_TIFFfree(buf);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;TIFFClose(tif);<br>
&nbsp;&nbsp;&nbsp;&nbsp;}<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>
&nbsp;&nbsp;&nbsp;&nbsp;TIFF* tif = TIFFOpen("myfile.tif", "r");<br>
&nbsp;&nbsp;&nbsp;&nbsp;if (tif) {<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;uint32 imageWidth, imageLength;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;uint32 tileWidth, tileLength;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;uint32 x, y;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;tdata_t buf;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &amp;imageWidth);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &amp;imageLength);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;TIFFGetField(tif, TIFFTAG_TILEWIDTH, &amp;tileWidth);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;TIFFGetField(tif, TIFFTAG_TILELENGTH, &amp;tileLength);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;buf = _TIFFmalloc(TIFFTileSize(tif));<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;for (y = 0; y &lt; imagelength; y += tilelength)<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;for (x = 0; x &lt; imagewidth; x += tilewidth)<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;tiffreadtile(tif, buf, x, y, 0);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;_tifffree(buf);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;tiffclose(tif);<br>
&nbsp;&nbsp;&nbsp;&nbsp;}<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>
&nbsp;&nbsp;&nbsp;&nbsp;TIFF* tif = TIFFOpen("myfile.tif", "r");<br>
&nbsp;&nbsp;&nbsp;&nbsp;if (tif) {<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;tdata_t buf;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;ttile_t tile;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;buf = _TIFFmalloc(TIFFTileSize(tif));<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;for (tile = 0; tile &lt; tiffnumberoftiles(tif); tile++)<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;tiffreadencodedtile(tif, tile, buf, (tsize_t) -1);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;_tifffree(buf);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;tiffclose(tif);<br>
&nbsp;&nbsp;&nbsp;&nbsp;}<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>

87
src/3rdparty/libtiff/html/man/TIFFClose.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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>

98
src/3rdparty/libtiff/html/man/TIFFDataWidth.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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>

106
src/3rdparty/libtiff/html/man/TIFFError.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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 &lt;stdarg.h&gt;</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>

113
src/3rdparty/libtiff/html/man/TIFFFlush.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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
&minus; 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 &minus; 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>

1446
src/3rdparty/libtiff/html/man/TIFFGetField.3tiff.html vendored
View File

File diff suppressed because it is too large Load Diff

421
src/3rdparty/libtiff/html/man/TIFFOpen.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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
(&lsquo;&lsquo;r&rsquo;&rsquo;), writing
(&lsquo;&lsquo;w&rsquo;&rsquo;), or appending
(&lsquo;&lsquo;a&rsquo;&rsquo;) 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&rsquo;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&rsquo;s contents in memory; c.f.
<i>mmap</i>(2) and <i>munmap</i>(2). The <i>clientdata</i>
parameter is an opaque &lsquo;&lsquo;handle&rsquo;&rsquo;
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 &lsquo;&lsquo;r&rsquo;&rsquo;,
&lsquo;&lsquo;w&rsquo;&rsquo;, and
&lsquo;&lsquo;a&rsquo;&rsquo; 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 &lsquo;&lsquo;strip
chopping&rsquo;&rsquo; 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
&lsquo;&lsquo;b&rsquo;&rsquo; and
&lsquo;&lsquo;l&rsquo;&rsquo; option flags may be included
in the call to open a file; for example,
&lsquo;&lsquo;wb&rsquo;&rsquo; or
&lsquo;&lsquo;wl&rsquo;&rsquo;.</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>&quot;%s&quot;: Bad mode</b>. The specified
<i>mode</i> parameter was not one of
&lsquo;&lsquo;r&rsquo;&rsquo; (read),
&lsquo;&lsquo;w&rsquo;&rsquo; (write), or
&lsquo;&lsquo;a&rsquo;&rsquo; (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 (&lsquo;&lsquo;a&rsquo;&rsquo;). 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>

225
src/3rdparty/libtiff/html/man/TIFFPrintDirectory.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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>

319
src/3rdparty/libtiff/html/man/TIFFRGBAImage.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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&rsquo;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
&lsquo;&lsquo;<i>put methods</i>&rsquo;&rsquo; 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-&gt;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
&lsquo;&lsquo;<i>get method</i>&rsquo;&rsquo; 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 &quot;PhotometricInterpretation&quot;
tag</b>. The image did not have a tag that describes how to
display the data.</p>
<!-- INDENTATION -->
<p><b>No &quot;PhotometricInterpretation&quot; 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 &quot;PhotometricInterpretation&quot; 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 &quot;Colormap&quot; 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&amp;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>

218
src/3rdparty/libtiff/html/man/TIFFReadDirectory.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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&mdash; 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 &lsquo;&lsquo;chopped
strips&rsquo;&rsquo; 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 &quot;%s&quot;</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 &quot;%s&quot;
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 &quot;%s&quot; (%lu,
expecting %lu); tag ignored</b>. The specified tag&rsquo;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 &quot;%s&quot;</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 &quot;%s&quot;;
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
&quot;ImageLength&quot; 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
&quot;PlanarConfig&quot; 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
&quot;StripOffsets&quot; 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
&quot;TileOffsets&quot; 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
&quot;StripByteCounts&quot; 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
&quot;StripByteCounts&quot; 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 &quot;StripByteCounts&quot; 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>

133
src/3rdparty/libtiff/html/man/TIFFReadEncodedStrip.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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 &lsquo;&lsquo;raw
strip number.&rsquo;&rsquo; 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 &minus;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>

130
src/3rdparty/libtiff/html/man/TIFFReadEncodedTile.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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 &lsquo;&lsquo;raw tile
number.&rsquo;&rsquo; 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
&minus;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>

301
src/3rdparty/libtiff/html/man/TIFFReadRGBAImage.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</b></p>
<!-- INDENTATION -->
<p><b>#define TIFFGetR(abgr) ((abgr) &amp; 0xff)<br>
#define TIFFGetG(abgr) (((abgr) &gt;&gt; 8) &amp; 0xff)<br>
#define TIFFGetB(abgr) (((abgr) &gt;&gt; 16) &amp; 0xff)<br>
#define TIFFGetA(abgr) (((abgr) &gt;&gt; 24) &amp;
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 &quot;PhotometricInterpretation&quot;
tag</b>. The image did not have a tag that describes how to
display the data.</p>
<!-- INDENTATION -->
<p><b>No &quot;PhotometricInterpretation&quot; 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 &quot;PhotometricInterpretation&quot; 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 &quot;Colormap&quot; 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&amp;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>

208
src/3rdparty/libtiff/html/man/TIFFReadRGBAStrip.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</b></p>
<!-- INDENTATION -->
<p><b>#define TIFFGetR(abgr) ((abgr) &amp; 0xff)<br>
#define TIFFGetG(abgr) (((abgr) &gt;&gt; 8) &amp; 0xff)<br>
#define TIFFGetB(abgr) (((abgr) &gt;&gt; 16) &amp; 0xff)<br>
#define TIFFGetA(abgr) (((abgr) &gt;&gt; 24) &amp;
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&rsquo;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&rsquo;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 &quot;PhotometricInterpretation&quot;
tag</b>. The image did not have a tag that describes how to
display the data.</p>
<!-- INDENTATION -->
<p><b>No &quot;PhotometricInterpretation&quot; 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 &quot;PhotometricInterpretation&quot; 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 &quot;Colormap&quot; 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&amp;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>

261
src/3rdparty/libtiff/html/man/TIFFReadRGBATile.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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) &amp; 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) &gt;&gt; 8) &amp; 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) &gt;&gt; 16) &amp; 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) &gt;&gt; 24) &amp; 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&rsquo;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&rsquo;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 &quot;PhotometricInterpretation&quot;
tag</b>. The image did not have a tag that describes how to
display the data.</p>
<!-- INDENTATION -->
<p><b>No &quot;PhotometricInterpretation&quot; 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 &quot;PhotometricInterpretation&quot; 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 &quot;Colormap&quot; 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&amp;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>

109
src/3rdparty/libtiff/html/man/TIFFReadRawStrip.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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 &lsquo;&lsquo;raw strip number.&rsquo;&rsquo; 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
&minus;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>

111
src/3rdparty/libtiff/html/man/TIFFReadRawTile.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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 &lsquo;&lsquo;raw tile number.&rsquo;&rsquo; 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
&minus;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>

157
src/3rdparty/libtiff/html/man/TIFFReadScanline.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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 &minus;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>

133
src/3rdparty/libtiff/html/man/TIFFReadTile.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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>&gt;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 &minus;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>

122
src/3rdparty/libtiff/html/man/TIFFSetDirectory.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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&rsquo;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 &lsquo;&lsquo;directory
count&rsquo;&rsquo; field.</p>
<!-- INDENTATION -->
<p><b>%s: Error fetching directory link</b>. An error was
encountered while reading the &lsquo;&lsquo;link
value&rsquo;&rsquo; 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>

1362
src/3rdparty/libtiff/html/man/TIFFSetField.3tiff.html vendored
View File

File diff suppressed because it is too large Load Diff

108
src/3rdparty/libtiff/html/man/TIFFWarning.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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 &lt;stdargh.h&gt;</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>

176
src/3rdparty/libtiff/html/man/TIFFWriteDirectory.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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&rsquo;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&rsquo;s
new location. This is particularly important in cases where
the size of the directory and pointed to data has grown, so
it won&rsquo;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 &quot;%s&quot;</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>

153
src/3rdparty/libtiff/html/man/TIFFWriteEncodedStrip.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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 &lsquo;&lsquo;raw strip
number.&rsquo;&rsquo; 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>&minus;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 &quot;ImageWidth&quot; before
writing data</b>. The image&rsquo;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 &quot;PlanarConfiguration&quot;
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&quot;</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>

147
src/3rdparty/libtiff/html/man/TIFFWriteEncodedTile.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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
&lsquo;&lsquo;raw tile number.&rsquo;&rsquo; 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>&minus;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 &quot;ImageWidth&quot; before
writing data</b>. The image&rsquo;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 &quot;PlanarConfiguration&quot;
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&quot;</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>

144
src/3rdparty/libtiff/html/man/TIFFWriteRawStrip.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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>&minus;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 &quot;ImageWidth&quot; before writing
data</b>. The image&rsquo;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 &quot;PlanarConfiguration&quot; 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&quot;</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>

128
src/3rdparty/libtiff/html/man/TIFFWriteRawTile.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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>&minus;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 &quot;ImageWidth&quot; before writing
data</b>. The image&rsquo;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 &quot;PlanarConfiguration&quot; 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&quot;</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>

206
src/3rdparty/libtiff/html/man/TIFFWriteScanline.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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 &minus;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 &quot;ImageWidth&quot; before writing
data</b>. The image&rsquo;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 &quot;PlanarConfiguration&quot; 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 &quot;ImageLength&quot; 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>

115
src/3rdparty/libtiff/html/man/TIFFWriteTile.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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>&gt;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 &minus;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>

116
src/3rdparty/libtiff/html/man/TIFFbuffer.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;
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
&lsquo;&lsquo;intelligent clients&rsquo;&rsquo; 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 &minus;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>

116
src/3rdparty/libtiff/html/man/TIFFcodec.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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>

975
src/3rdparty/libtiff/html/man/TIFFcolor.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</b></p>
<!-- INDENTATION -->
<p><b>int TIFFYCbCrToRGBInit(TIFFYCbCrToRGB
*</b><i>ycbcr</i><b>, float *</b><i>luma</i><b>, float
*</b><i>refBlackWhite&quot;</i><b>);&quot;<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&quot;</i><b>,</b><i>uint32</i><b>*&quot;</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-&gt;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(&quot;YCbCr-&gt;RGB&quot;,</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>&quot;No space for YCbCr-&gt;RGB conversion
state&quot;);</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,
&amp;luma);<br>
TIFFGetFieldDefaulted(tif, TIFFTAG_REFERENCEBLACKWHITE,
&amp;refBlackWhite);<br>
if (TIFFYCbCrToRGBInit(ycbcr, luma, refBlackWhite) &lt;
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-&gt;ycbcr, Y, Cb, Cr, &amp;r, &amp;g,
&amp;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-&gt;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 -&gt; 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 -&gt; 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-&gt;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(&quot;CIE L*a*b*-&gt;RGB&quot;,</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>&quot;No space for CIE L*a*b*-&gt;RGB conversion
state.&quot;);</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,
&amp;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, &amp;display_sRGB,
refWhite) &lt; 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(&quot;CIE L*a*b*-&gt;RGB&quot;,</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>&quot;Failed to initialize CIE L*a*b*-&gt;RGB conversion
state.&quot;);</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, &amp;X, &amp;Y,
&amp;Z);</p>
</td>
<tr valign="top" align="left">
<td width="24%"></td>
<td width="75%">
<p>TIFFXYZToRGB(cielab, X, Y, Z, &amp;r, &amp;g,
&amp;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&rsquo;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>

110
src/3rdparty/libtiff/html/man/TIFFmemory.3tiff.html vendored
View File

@ -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, &minus; 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 &lt;tiffio.h&gt;</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>

148
src/3rdparty/libtiff/html/man/TIFFquery.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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>

95
src/3rdparty/libtiff/html/man/TIFFsize.3tiff.html vendored
View File

@ -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, &minus; 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 &lt;tiffio.h&gt;</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>

129
src/3rdparty/libtiff/html/man/TIFFstrip.3tiff.html vendored
View File

@ -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
&minus; 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 &lt;tiffio.h&gt;</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>

110
src/3rdparty/libtiff/html/man/TIFFswab.3tiff.html vendored
View File

@ -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
&minus; 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 &lt;tiffio.h&gt;</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>

141
src/3rdparty/libtiff/html/man/TIFFtile.3tiff.html vendored
View File

@ -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 &minus; 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 &lt;tiffio.h&gt;</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>&gt;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>

252
src/3rdparty/libtiff/html/man/fax2ps.1.html vendored
View File

@ -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 &minus; convert a <small>TIFF</small> facsimile to
compressed PostScript&trade;</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>&minus;x</b> and <b>&minus;y</b> options can be used to
specify the horizontal and vertical image resolutions
(lines/inch), respectively. If the <b>&minus;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>&minus;W</b> and <b>&minus;H</b> options.</p>
<!-- INDENTATION -->
<p>By default <i>fax2ps</i> generates PostScript for all
pages in the file. The <b>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>

607
src/3rdparty/libtiff/html/man/fax2tiff.1.html vendored
View File

@ -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 &minus; 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>&minus;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
&lsquo;&lsquo;raw&rsquo;&rsquo; 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,
&lsquo;&lsquo;classic&rsquo;&rsquo;, format is created if
the <b>&minus;c</b> option is used. (The Class F format can
also be requested with the <b>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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 &lsquo;&lsquo;zero padding&rsquo;&rsquo;
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>&minus;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>&minus;c</b></p>
</td>
<td width="5%"></td>
<td width="80%">
<p>Generate &quot;classic&quot; Group 3 TIFF format.</p>
</td>
<td width="0%">
</td>
<tr valign="top" align="left">
<td width="10%"></td>
<td width="3%">
<p><b>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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 &lsquo;&lsquo;top
left&rsquo;&rsquo; 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>

141
src/3rdparty/libtiff/html/man/gif2tiff.1.html vendored
View File

@ -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 &minus; 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 &amp; 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>&minus;c</b></p>
</td>
<td width="5%"></td>
<td width="80%">
<p>Specify a compression scheme to use when writing image
data: <b>&minus;c none</b> for no compression, <b>&minus;c
packbits</b> for the PackBits compression algorithm,
<b>&minus;c zip</b> for the Deflate compression algorithm,
and <b>&minus;c lzw</b> for Lempel-Ziv &amp; Welch (the
default).</p>
</td>
<td width="0%">
</td>
<tr valign="top" align="left">
<td width="10%"></td>
<td width="3%">
<p><b>&minus;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&rsquo;s
<i>fromgif</i> program which, in turn, is based on Marcel
J.E. Mol&rsquo;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>

64
src/3rdparty/libtiff/html/man/index.html vendored
View File

@ -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>

3137
src/3rdparty/libtiff/html/man/libtiff.3tiff.html vendored
View File

File diff suppressed because it is too large Load Diff

189
src/3rdparty/libtiff/html/man/pal2rgb.1.html vendored
View File

@ -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 &minus; 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>&minus;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>&minus;C</b> option can be used to explicitly specify the
number of bits for colormap entries: <b>&minus;C 8</b> for
8-bit values, <b>&minus;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>&minus;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>&minus;p
contig</b> for samples packed contiguously, and <b>&minus;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>&minus;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>&minus;c packbits</b> for
Macintosh Packbits, <b>&minus;c lzw</b> for Lempel-Ziv &amp;
Welch, <b>&minus;c zip</b> for Deflate, <b>&minus;c none</b>
for no compression. If no compression-related option is
specified, the input file&rsquo;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>&minus;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>&minus;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>

141
src/3rdparty/libtiff/html/man/ppm2tiff.1.html vendored
View File

@ -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 &minus; 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>&minus;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 &amp; 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>&minus;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>&minus;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>

139
src/3rdparty/libtiff/html/man/ras2tiff.1.html vendored
View File

@ -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 &minus; 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 &amp; 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>&minus;c</b></p>
</td>
<td width="6%"></td>
<td width="80%">
<p>Specify a compression scheme to use when writing image
data: <b>&minus;c none</b> for no compression, <b>&minus;c
packbits</b> for the PackBits compression algorithm,
<b>&minus;c jpeg</b> for the baseline JPEG compression
algorithm, <b>&minus;c zip</b> for the Deflate compression
algorithm, and <b>&minus;c lzw</b> for Lempel-Ziv &amp;
Welch (the default).</p>
</td>
<td width="0%">
</td>
<tr valign="top" align="left">
<td width="10%"></td>
<td width="2%">
<p><b>&minus;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>

510
src/3rdparty/libtiff/html/man/raw2tiff.1.html vendored
View File

@ -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 &minus; 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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;c</b></p>
</td>
<td width="5%"></td>
<td width="80%">
<p>Specify a compression scheme to use when writing image
data: <b>&minus;c none</b> for no compression, <b>&minus;c
packbits</b> for the PackBits compression algorithm (the
default), <b>&minus;c jpeg</b> for the baseline JPEG
compression algorithm, <b>&minus;c zip</b> for the Deflate
compression algorithm, and <b>&minus;c lzw</b> for
Lempel-Ziv &amp; 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>&minus;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&rsquo;t guess the
header size, number of bands and data type, so it should be
specified manually. If you don&rsquo;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>

155
src/3rdparty/libtiff/html/man/rgb2ycbcr.1.html vendored
View File

@ -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 &minus; 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>&minus;h</b> and <b>&minus;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>&minus;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>&minus;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>&minus;c</b></p>
</td>
<td width="5%"></td>
<td width="80%">
<p>Specify a compression scheme to use when writing image
data: <b>&minus;c none</b> for no compression, <b>&minus;c
packbits</b> for the PackBits compression algorithm (the
default), <b>&minus;c jpeg</b> for the JPEG compression
algorithm, <b>&minus;c zip</b> for the deflate compression
algorithm, and <b>&minus;c lzw</b> for Lempel-Ziv &amp;
Welch.</p>
</td>
<td width="0%">
</td>
<tr valign="top" align="left">
<td width="10%"></td>
<td width="3%">
<p><b>&minus;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>&minus;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>&minus;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>

147
src/3rdparty/libtiff/html/man/sgi2tiff.1.html vendored
View File

@ -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 &minus; 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 &amp; 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>&minus;c</b></p>
</td>
<td width="5%"></td>
<td width="80%">
<p>Specify a compression scheme to use when writing image
data: <b>&minus;c none</b> for no compression, <b>&minus;c
packbits</b> for the PackBits compression algorithm),
<b>&minus;c jpeg</b> for the baseline JPEG compression
algorithm, <b>&minus;c zip</b> for the Deflate compression
algorithm, and <b>&minus;c lzw</b> for Lempel-Ziv &amp;
Welch (the default).</p>
</td>
<td width="0%">
</td>
<tr valign="top" align="left">
<td width="10%"></td>
<td width="3%">
<p><b>&minus;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>&minus;p
contig</b> for samples packed contiguously, and <b>&minus;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>&minus;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>

148
src/3rdparty/libtiff/html/man/thumbnail.1.html vendored
View File

@ -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 &minus; 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>&minus;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>&minus;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>&minus;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>

161
src/3rdparty/libtiff/html/man/tiff2bw.1.html vendored
View File

@ -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 &minus; 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>&minus;R</b>,
<b>&minus;G</b>, and <b>&minus;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>&minus;c</b></p>
</td>
<td width="5%"></td>
<td width="80%">
<p>Specify a compression scheme to use when writing image
data: <b>&minus;c none</b> for no compression, <b>&minus;c
packbits</b> for the PackBits compression algorithm,
<b>&minus;c zip</b> for the Deflate compression algorithm,
<b>&minus;c g3</b> for the CCITT Group 3 compression
algorithm, <b>&minus;c g4</b> for the CCITT Group 4
compression algorithm, and <b>&minus;c lzw</b> for
Lempel-Ziv &amp; Welch (the default).</p>
</td>
<td width="0%">
</td>
<tr valign="top" align="left">
<td width="10%"></td>
<td width="3%">
<p><b>&minus;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>&minus;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>&minus;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>&minus;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>

609
src/3rdparty/libtiff/html/man/tiff2pdf.1.html vendored
View File

@ -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 &minus; 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>&minus;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>&minus;j</b> or <b>&minus;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>&minus;j</b> and
<b>&minus;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>&minus;d</b> and
<b>&minus;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>&minus;x</b> and <b>&minus;y</b> options.
The page size can be set using the <b>&minus;p</b> option
for paper size, or <b>&minus;w</b> and <b>&minus;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>&minus;u</b> option, the default unit is inch.</p>
<!-- INDENTATION -->
<p>Various items of the output document information can be
set with the <b>&minus;e</b>, <b>&minus;c</b>,
<b>&minus;a</b>, <b>&minus;t</b>, <b>&minus;s</b>, and
<b>&minus;k</b> options. Setting the argument of the option
to &quot;&quot; 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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;b</b></p>
</td>
<td width="7%"></td>
<td width="77%">
<p>Set PDF &lsquo;&lsquo;Interpolate&rsquo;&rsquo; user
preference.</p>
</td>
<tr valign="top" align="left">
<td width="11%"></td>
<td width="2%">
<p><b>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;f</b></p>
</td>
<td width="13%"></td>
<td width="57%">
<p>Set PDF &lsquo;&lsquo;Fit Window&rsquo;&rsquo; 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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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 &minus;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
&lsquo;&lsquo;Document&rsquo;&rsquo;, and setting the
&lsquo;&lsquo;Fit Window&rsquo;&rsquo; 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 &minus;p letter &minus;j &minus;q 75 &minus;t &quot;Document&quot; &minus;f &minus;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>

532
src/3rdparty/libtiff/html/man/tiff2ps.1.html vendored
View File

@ -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 &minus; convert a <small>TIFF</small> image to
PostScript&trade;</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>&minus;w</b> and <b>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;w</b> and the
<b>&minus;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>&minus;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>&minus;e</b></p>
</td>
<td width="5%"></td>
<td width="80%">
<p>Force the generation of Encapsulated PostScript (implies
<b>&minus;z</b>).</p>
</td>
<td width="0%">
</td>
<tr valign="top" align="left">
<td width="10%"></td>
<td width="3%">
<p><b>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;H</b>
option.</p>
</td>
<td width="0%">
</td>
<tr valign="top" align="left">
<td width="10%"></td>
<td width="3%">
<p><b>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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 &minus;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 &minus;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 &minus;h11 &minus;w8.5 &minus;H14 &minus;L.5 foo.tif &gt; 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>&minus;w</b> and
<b>&minus;h</b> options. We will accept a small amount of
vertical compression, so <b>&minus;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>&minus;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>

162
src/3rdparty/libtiff/html/man/tiff2rgba.1.html vendored
View File

@ -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 &minus; 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
&gt; 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>&minus;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>&minus;c</b></p>
</td>
<td width="5%"></td>
<td width="80%">
<p>Specify a compression scheme to use when writing image
data: <b>&minus;c none</b> for no compression (the default),
<b>&minus;c packbits</b> for the PackBits compression
algorithm, <b>&minus;c zip</b> for the Deflate compression
algorithm, <b>&minus;c jpeg</b> for the JPEG compression
algorithm, and <b>&minus;c lzw</b> for Lempel-Ziv &amp;
Welch.</p>
</td>
<td width="0%">
</td>
<tr valign="top" align="left">
<td width="11%"></td>
<td width="2%">
<p><b>&minus;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>&minus;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>&minus;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>&minus;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>

156
src/3rdparty/libtiff/html/man/tiffcmp.1.html vendored
View File

@ -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 &minus; 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&minus;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>&minus;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>&minus;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>&minus;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>

522
src/3rdparty/libtiff/html/man/tiffcp.1.html vendored
View File

@ -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 &minus; 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>&minus;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>&minus;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>&minus;C</b></p>
</td>
<td width="5%"></td>
<td width="80%">
<p>Suppress the use of &lsquo;&lsquo;strip
chopping&rsquo;&rsquo; 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>&minus;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 &amp;
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
&lsquo;&lsquo;:&rsquo;&rsquo;-separated list to the
&lsquo;&lsquo;g3&rsquo;&rsquo; option; e.g. <b>&minus;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
&lsquo;&lsquo;:&rsquo;&rsquo;-separated list to the
&lsquo;&lsquo;lzw&rsquo;&rsquo; option; e.g. <b>&minus;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>&minus;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>&minus;f
lsb2msb</b> will force data to be written with the FillOrder
tag set to <small>LSB2MSB,</small> while <b>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;p
contig</b> will force data to be written with multi-sample
data packed together, while <b>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;,=</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 &lsquo;,&rsquo; in
parsing image directory indices in files. This is necessary
if filenames contain commas. Note that <b>&minus;,=</b> with
whitespace immediately following will disable the special
meaning of the &lsquo;,&rsquo; 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 &minus;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 &minus;c g4 &minus;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
&lsquo;,&rsquo; 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
&lsquo;&lsquo;album.tif&rsquo;&rsquo; to
&lsquo;&lsquo;result.tif&rsquo;&rsquo;:</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 &lsquo;&lsquo;CCD.tif&rsquo;&rsquo; 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 &minus;c none &minus;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
&lsquo;&lsquo;CCD,X.tif&rsquo;&rsquo;, the <b>&minus;,=</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 &minus;c none &minus;,=% &minus;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>

851
src/3rdparty/libtiff/html/man/tiffcrop.1.html vendored
View File

@ -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 &minus; 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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;C</b></p>
</td>
<td width="5%"></td>
<td width="80%">
<p>Suppress the use of &lsquo;&lsquo;strip
chopping&rsquo;&rsquo; 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>&minus;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 &amp;
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
&lsquo;&lsquo;:&rsquo;&rsquo;-separated list to the
&lsquo;&lsquo;g3&rsquo;&rsquo; option; e.g. <b>&minus;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
&lsquo;&lsquo;:&rsquo;&rsquo;-separated list to the
&lsquo;&lsquo;lzw&rsquo;&rsquo; option; e.g. <b>&minus;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>&minus;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>&minus;f lsb2msb</b> will force data to be written with
the FillOrder tag set to <small>LSB2MSB,</small> while
<b>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;p contig</b> will force data to be written with
multi-sample data packed together, while <b>&minus;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>&minus;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>&minus;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>&minus;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>&minus;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>&minus;,={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 &rsquo;,&rsquo; in parsing
image directory indices in files. This is necessary if
filenames contain commas. Note that &rsquo;,=&rsquo; with
whitespace immediately following will disable the special
meaning of the &rsquo;,&rsquo; 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 &quot;album.tif&quot;
to &quot;result.tif&quot;:</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>

Some files were not shown because too many files have changed in this diff Show More