netpbm-8.2/0040550000076400000000000000000007066315335011674 5ustar bryanhrootnetpbm-8.2/COPYRIGHT0100660000076400000000000000062505515306026013166 0ustar bryanhrootNetpbm consists of code contributed by many authors. In every file of the source code, there is a copyright notice, telling you what you may or may not do with the code. All authors have granted you the right to use and distribute their code without having to pay them, as long as you do it on a non-commercial basis. Most authors allow you to do even more, but remember to check their copyright notices. netpbm-8.2/FORMATS0100660000076400000000000000440705453764443012747 0ustar bryanhrootPBM handles the following black&white formats: Sun icon file reading writing X10 and X11 bitmap file reading writing MacPaint reading writing CMU window manager format reading writing MGR format reading writing Group 3 FAX reading writing GEM .img format reading writing Bennet Yee's "face" format reading writing Atari Degas .pi3 format reading writing Andrew Toolkit raster object reading writing Xerox doodle brushes reading ASCII graphics writing HP LaserJet format writing GraphOn graphics writing BBN BitGraph graphics writing Printronix format writing Gemini 10x printer format writing Epson printer format writing Unix plot(5) file writing Zinc Interface Library icon writing PGM handles the following grayscale formats: Usenix FaceSaver(tm) file reading writing FITS reading writing Lisp Machine bit-array-file reading writing raw grayscale bytes (e.g. the Molecular Dynamics and Leica CSLM formats) reading Biorad CSLM images reading HIPS reading PostScript "image" data reading PPM handles the following color formats: GIF reading writing IFF ILBM reading writing PICT reading writing Atari Degas .pi1 format reading writing XPM (X Window System ASCII pixmaps) reading writing PC Paintbrush .pcx format reading writing TrueVision Targa file reading writing HP PaintJet format reading writing Abekas YUV format reading writing MTV/PRT ray-tracer output reading QRT ray-tracer output reading Img-whatnot file reading Xim file reading Atari uncompressed Spectrum reading Atari compressed Spectrum reading NCSA Interactive Color Raster writing X11 "puzzle" file writing Motif UIL icon file writing DEC sixel format writing AutoCAD slide format reading writing AutoCAD DXB format writing PNM handles the following multi-type formats: Sun raster file reading writing TIFF reading writing X11 window dump file reading writing X10 window dump file reading PostScript writing Zeiss CSLM images (the old format) reading netpbm-8.2/HISTORY0100660000076400000000000004601707060435257012772 0ustar bryanhrootNetpbm was developed, in 1993, to replace the former standard graphics conversion package pbmplus, which was no longer being maintained and enhanced. It was derived directly from pbmplus, which was written by Jef Poskanzer, jef@well.sf.ca.us. Then netpbm apparently fell into neglect with the last release by its regular maintainer in March 1994. In September of 1995 Anthony Thyssen released an unofficial update of it called netpbm-1mar1994.p1, while disclaiming any responsibity for ongoing upkeep. At one time, the documentation advised that the mailing list pbmplus@netcom.com was responsible for the package, but that mailing list doesn't exist anymore. Other documentation referred to a netpbm mailing list which also doesn't exist anymore (both findings as of April 1999). In September 1999, Bryan Henderson needed some minor bugs fixed, and wanted to clean up the mess of unsupported versions and outdated documentation of these tools. After checking around to see if anyone had any claims of ownership of the package, and finding none, Bryan assumed control and responsibility for netpbm. pbmplus and netpbm were originally part of the body of X/Windows contributed software, distributed on ftp.x.org (directory contrib/utilities). Bryan didn't receive a response to a request to an inquiry to the ftp.x.org owner (at the address given on the site) as to the prospect of cleaning up the netpbm related files there. So Bryan instead made Metalab the new home of the source code. Sunsite already had binaries of netpbm and pbmplus built for GNU/Linux systems. CHANGE HISTORY BEGINNING WITH BRYAN'S RELEASE 8 ----------------------------------------------- 00.03.05 BJH Add CMYK capability to tifftopnm. 00.03.03 BJH Add pnmtotiffcmyk. Written by Andrew Cooke (Jara Software) jara@andrewcooke.free-online.co.uk 00.03.02 BJH Release 8.1 00.03.02 BJH Add pnmtopng and pngtopnm. I got these from ftp://ftp.au.netbsd.org/pub/NetBSD/packages/distfiles today. Release 2.37.3. I added an "unsigned" and changed the type of 'scaleval' to quiet compiler warnings. 00.03.01 BJH Fix xwdtopnm interpretation of 16 bit TrueColor files. Thanks to Martin Kroeker, mk@daveg.com. 99.09.23 BJH Update xbmtopbm to recognize newer xbm format. CHANGES TO NETPBM THROUGH MARCH 1994 ------------------------------------ Functional changes to netpbm since 13 October 1993. Minor bug fixes and compatibility fixes are not documented in this file. PBM libpbm1.c strstr() added to libpbm1.c. libpbm5.c BDF font support added. pbmtext BDF font support added. pbmto4425 New filter. pbmtoln03 Command line parsing changed to pbmplus standard. PGM pgmnoise New filter. PPM picttoppm Updated ppm3d New facility. ppmchange New filter. ppmdim New filter. ppmflash New filter. ppmmix New filter. ppmntsc New filter. ppmqvga Option parsing changed to pbmplus standard. ppmshift New filter. ppmspread New filter. ppmtoxpm Prototypes added. xpmtoppm Prototypes added. ilbmtoppm Updated. ppmtoilbm Updated. PNM pnmtoddif New filter. pnmhistmap New facility. pnmtops New option (-nocenter) added. Functional changes to netpbm since 7 December 1993. Minor bug fixes and compatibility fixes are not documented in this file. PGM asciitopgm New filter. fitstopgm Replaced by fitstopnm. pgmtofits Replaced by pnmtofits. pgmtopbm Upgraded. pgmkernel New filter. PPM ppmchange Upgraded. xvminitoppm New filter. PNM pnmalias New filter. pnmtofits Replacement for pgmtofits. fitstopnm Replacement for fitstopgm. pnmtosgi New filter. sgitopnm New filter. pstopnm New filter. CHANGES BETWEEN PBMPLUS AND THE ORIGINAL NETPBM ----------------------------------------------- The following is new in Netpbm (compared to Pbmplus): PBM pbmtext BDF font support added. pbmto4425 Display on an AT&T 4425 Ascii terminal. pbmtoascii A new improved version. pbmtoln03 Convert to DEC LN03+. pbmtolps Fast PostScript creator. pbmtopk Conversion to/from a packed (PK) format font. pktopbm pbmclean Flip isolated pixels. pbmpscale Enlarge pbm image with edge smoothing. PGM asciitopgm Convert an ascii image into pgm. pbmtopgm Convert pbm to pgm by averaging areas. rawtopgm Handles input files without specification of the file size, assuming the input image is quadratic. It also supports a -tb (top bottom flip) option. bioradtopgm Conversion utility for files created by Biorad confocal microscopes. spottopgm Convert SPOT satellite images to pgm. pgmkernel Generate a convolution kernel. pgmnoise Create a pgm file with random pixels. PPM bmptoppm Conversion to/from windows bitmap format. ppmtobmp ppmtogif Updated version. giftoppm Removed (see giftopnm). ppmtoilbm Updated version. ilbmtoppm picttoppm Updated version. ppmtopict ppmtoxpm Updated version, which supports xpm version 3. xpmtoppm ppmtomap Extract all colours from a ppm file. ppmtomitsu Convert to Mitsubishi S340-10 printer format. xvminitoppm Convert an XV thumbnail picture to ppm. ppmtoyuvsplit Conversion to/from YUV triplets. (MPEG / JPEG). yuvsplittoppm ppm3d Create a red/blue stereo image. ppmbrighten Change image saturation and value on an HSV map. ppmchange Change all pixels of one colour to another in a portable pixmap ppmdim Dim a ppm file down to total blackness. ppmdist Simplistic grayscale assignment for machine generated colour images. ppmflash Brighten a picture up to complete white-out ppmmix Blend together two portable pixmaps. ppmnorm Normalize the contrast in a portable pixmap. ppmntsc Make a portable pixmap look like taken from an American TV. ppmqvga Eight plane quantization. ppmshift Shift lines of a portable pixmap left or right by a random amount. ppmspread Displace a portable pixmap's pixels by a random amount. ppmtopjxl Convert a ppm file into an HP PaintJet XL PCL file. PNM pnmtops New option (-nocenter) added. pnmtofits Replacement for pgmtofits/fitstopgm fitstopnm pnmtosgi Conversion to/from sgi image format. sgitopnm pnmtosir Conversion to/from Solitaire image recorder format. sirtopnm giftopnm Replaces giftoppm. Examines the input image and produces a pbm, pgm, or ppm output. pstopnm Convert PostScript to pnm. Requires Ghostscript. zeisstopnm Conversion utility for files created by Zeiss confocal microscopes (the old standard). pnmalias Anti aliasing filter. pnmcomp Composite two portable anymaps together. pnmcrop New options added. pnmpad Add borders to anymap. LIBTIFF A new release of libtiff is included. Please read its supporting documentation. CHANGE LOG FROM PBMPLUS ----------------------- Changes since the 30oct91 patch version: Fixed uninitialized variable in ppmtotga. (John Walker) Added pgmcrater, ppmforge, ppmtoacad, sldtoppm. (John Walker) Slight change to the p?mmerge.c front-ends to allow for main programs that return instead of exitting. Minor clarifications to the pnmconvol man page. Fixed xwdtopnm to read some 16-bit True/Direct files. (David Elliott) Fixed uninitialized variables in pnmtotiff. (Larry Rosenstein, Bayles Holt) Added a couple of checks for \r while reading whitespace. (Larry Rosenstein) Removed all the BROKENPUTC stuff. Now we ignore all return values from putc(), and check ferror() in pm_close(). Added pm_close() calls to many of the filters. Fixed pnmdepth to check for too-large newmaxvals. Improved rounding in pnmdepth and PPM_DEPTH macro. (Tom Lane) Minor fix to ppmtouil. (Mohsen Banan) Added new Imakefiles. (Rainer Klute) Changes since the 05oct91 X11R5 contrib tape version: Fixed minor SysV config error in pbmplus.h. (Tom Lane) Fixed tifftopnm so that BITSPERSAMPLE and SAMPLESPERPIXEL default correctly. Fixed possible bug in tgatoppm line-interleaving code. (Arthur David Olson) Fixed tifftopnm so that colormapped files are read correctly. (PauL Drews, Mike Wade) Corrected use of DefaultRGBDatabase / RGB_DB for imake sites. (Randal L. Schwartz) Bugfix to pnmtops color PostScript in -rle mode. (Angus Duggan) Added auto-turning to pnmtops. Added run-length encoding to ppmtotga. Space optimization to pgmoil. Changes since the 27sep91 comp.sources.misc distribution: Fixed spelling error in giftoppm. Fixed ppmrelief to not shrink the image by 2 rows and columns. Minor fix to pgmramp. Fixed off-by-one error in pnmtoxwd. Man page fix for pnmgamma. (Arthur David Olson) Converted ANSI trigraphs in ppmtosixel into good old octal. (Jeff Glover) Fix to 24/32 bit case in rasttopnm. (Behr de Ruiter) Float/double portability fix to libppm4. (Bruce Holmer, Ronald Khoo) Fixed typo in compat.ksh. (Larry Virden) Fixed int/short incompatibility in tifftopnm. (Salik Rafiq) Changes during the extended beta test period, starting on 15jan91: Lots of fixes from: Anthony A. Datri, Arthur David Olson, David Brooks, David Elliott, Doug Claar, Duncan Sinclair, Francois Pinard, Gerard Leurs, Jim Hanko, Ken Laprade, Klaus U. Schallhorn, Markus Bolz, Mike Hench, Philip Gladstone, R C Smith, Selden E. Ball, Jr., Stephen Uitti, Steve Allen, Tom Lane, update.kpj-jaakkola@athena.dsv.su.se, Charles Karney, Unmesh Agarwala, Ed Pendzik, Juha Sarlin, Tom Tulinsky, Phillip Smith, Lai-King Mau, David Koblas, Mark Donovan. Added a global -version flag. Added bunches of statics and prototypes. Now compiles with zero warnings under gcc -ansi -pedantic. Changed #ifdef __STDC__ to #if __STDC__, since some non-compliant compilers define it as 0. Changed pm_message and pm_error to be varargs routines. Added a portable version of vfprintf for those systems which don't have it. Removed the option of not compiling the pgm and ppm parts. Very few people used it, and it added amazing complexity to the pnm programs, turning them into maintenance nightmares. Merged pbmpaste into pnmpaste. Merged pgmtops and ppmtops into pnmtops. Added auto-scaling and dpi / page size flags to pnmtops. Changed the interpretation of bits in pbmlife to conform with other tools. Changed xwdtopnm to ignore the pixel number in the xwd color structure. Added a -pseudodepth flag to pnmtoxwd. Updated tifftopnm for libtiff 2.4. Added many option flags to pnmtotiff. (J.T. Conklin) Added support for X11R5's new color specifiers rgb: and rgbi:. Added pgmtexture. (James Darrell McCauley) Added ppmtopj, pjtoppm, and ppmdither. (Christos Zoulas) Added ppmtotga. (Mark Shand) Added ppmtosixel. (Rick Vinci) Added pbmtoatk and atktopbm. (Bill Janssen) Added ppmtoyuv and yuvtoppm. (Marc Boucher) Fixes to picttoppm. (George Phillips) Added 24-bit support to ilbmtoppm. (Mark Thompson) Changes since the X.V11R4 / comp.sources.misc distribution of 22nov89: Added pgmramp, pgmedge, pgmtoppm, rgb3toppm, ppmtoxpm, pnmgamma, ximtoppm, pgmtofs, picttoppm, ppmtopict, ppmquantall, anytopnm, pi1toppm, ppmtopi1, sputoppm, spctoppm, pbmto10x, ppmtoicr, ppmmake, xpmtoppm, ppmtopuzz, ppmtouil, ybmtopbm, pbmtoybm, lispmtopgm, pgmtolispm, pbmtogem, pi3topbm, pbmtopi3, pbmtoepson, pbmtoplot, pbmtozinc, pbmtext, pnmnoraw, pnmmargin, pnmfile, pnmindex, ppmtorgb3, gouldtoppm, pgmbentley, pgmoil, ppmrelief, pnmtotiff, ppmtopcx. Merged some filters: rasttopbm and rasttoppm into rasttopnm; pbmtorast and ppmtorast into pnmtorast; xwdtopbm and xwdtoppm into xwdtopnm; pbmtoxwd and ppmtoxwd into pnmtoxwd. Promoted some filters: pcxtopbm to pcxtoppm; ppmarith to pnmarith; ppmconvol to pnmconvol; ppmcscale to pnmdepth; ppmrotate to pnmrotate; ppmscale to pnmscale; ppmshear to pnmshear; ppmsmooth to pnmsmooth; tifftopgm to tifftopnm - new version based on Sam Leffler's libtiff. Bugfixes to pbmtoicon, ppmtops. The Makefiles now have a "merge" option. All flags are now case-insensitive. Added $(MAKE) stuff to Makefile. Changed pnmsmooth from a csh script to a sh script. Made macro use in pbmtox10bm and pbmtoxbm more portable. Moved compataliases to compat.csh, and added compat.ksh. Made ppmtoilbm less Amiga-specific. Added -headerskip and -rowskip flags to rawtopgm. Enhanced rasttopnm to interpret 8-bit rasters with no colormap as grayscale. Changed sscanf %g to %f - some systems can't handle %g on input. Added -expand flag to pbmmask. Speedup to pnmflip - don't buffer if possible. Added color-name-to-value routine to ppm - uses X11's rgb.txt if present. Updated Imakefile support to reflect X.V11R4. Removed picttopbm. Improved pnmcut argument syntax so that negative coords work like pnmpaste. Added "magic" file, for use with the "file" program. 40% speedup for pgmnorm from Robert Stockton (rgs@cs.cmu.edu). Fixed long-standing bug involving colormaps on SPARCstations when compiled with gcc -- had to do with passing structs by value. Removed the -x flag from pnmtorast -- it's not really needed. Fixed subtle bug in the pnm reading code that caused pnmcat to blow it on images that differed greatly in width or height. New version of giftoppm that handles the GIF89a standard, and doesn't use fseek. Fixed fitstopgm to handle three-axis images, such as the Hubble pix. Xwdtopnm and pnmtoxwd finally handle byte-order properly. Added -xysize flag to pnmscale. Added conditional ANSI function prototypes to library routines. Added -noantialias flag to pnmrotate and pnmshear. Removed the TIPS file. No one ever sent in any new tips, so I just moved the few I had into the relevant man pages. That's probably where they belonged in the first place. Added justification flags to pnmcat. Added -map flag to ppmquant - user-specifiable colormap. Also, the Floyd-Steinberg error diffusion finally works right. Added -map flag to pgmtoppm. Added DirectColor support to xwdtopnm and pnmtoxwd. Speedup to pgmtolj from Arthur David Olson: avoid sending whitespace. Fix to pbmtogo from Bo Thide': 2D compression now works. Patch 1 to the X.V11R4 / comp.sources.misc distribution of 22nov89: Fixed bug in pgmtops -rle. Changes since the alt.sources distribution of 13sep89: Small corrections to ppmtorast, pgmtops. Moved pbm/tifftopbm to pgm/tifftopgm - it now handles grayscale TIFF files. Fixed tifftopgm to handle non-native byte order. Changes to tifftopgm to handle bogus AppleScan TIFF files, to have better command syntax, and to use stdio. Optimizations to xbmtopbm, pbmtoxbm, and pbmtox10bm, courtesy of Juha Sarlin, to make them go about three times as fast. Optimization to pgmtops and ppmtops to make them go three times as fast. Optimization to pnmcrop. Added PBMPLUS_BROKENPUTC defines in pbmplus.h to handle systems (such as ULTRIX) which have broken putc() macros. Rewrote ppmscale, pnmcat, and pgmhist to operate line-by-line, instead of reading in the whole image. Rewrote pnmflip to keep only one copy of the image in memory. Added pgmtofits, courtesy of Wilson H. Bent, plus bugfixes to fitstopgm and a patch to giftoppm to handle black&white GIF files. Added picttopbm and rawtopgm. Fixes to xwdtoppm and ppmtoxwd so they compile with SunOS cc as well as gcc. Another small change to ppmtoxwd having to do with colormap size. Changed macptopbm's -headersize flag to be -extraskip. Changed tgatoppm to read color values as BGRA instead of ARGB; the Targa documentation is apparently wrong about the order. Some changes to the Makefiles, partially to work around bugs in gnumake. Got g3topbm working, and added pbmtog3, courtesy of Paul Haeberli. Added some pixrect work-alike code so that rasttopbm, pbmtorast, rasttoppm, and ppmtorast can be used on non-Sun systems. This also provides a final solution to the persistent byte- and bit-order problems on 386's. Moved the SYSV-checking #ifdefs to *after* the include of pbm.h, which defines SYSV. Made all the #else's and #endif's ANSI-compliant. Added manual pages for libpbm, libpgm, libppm, and libpnm, courtesy of Tony Hansen. Changed man page installation so that pages from different sections can go in different directories. Fixed Imakefiles. Changes since the expo.lcs.mit.edu FTP distribution of 06sep89: Added #ifdefs to pnm/libpnm3.c to allow the PBM-PNM-only configuration. Small corrections to TIPS, pnm/Makefile, pnm/Imakefile, ppm/ppmrotate.1, ppm/ppmshear.1, ppm/ppmtoilbm.c, pbm/xwdtopbm.c, ppm/xwdtoppm.c, ppm/ppmtoxwd.c, ppm/ppmtoxwd.1, pbm/x11wd.h. Changes since the comp.sources.misc distribution of 31oct88: Added pbmreduce, pbmlife, pbmmask, and pbmupc. Added gemtopbm, tifftopbm, pcxtopbm, pbmtogo, mgrtopbm, pbmtomgr, cmuwmtopbm, pbmtocmuwm, g3topbm, and pbmtobg. Minor bugfix to pbmtolj. Slight restructuring of most of the programs to use vastly less memory. Various other minor optimizations. Fixed pbmtorast and rasttopbm to handle byte-swapped big-endian 386 boxes. Slight changes to argument syntax of pbmcrop, pbmmake, pbmreduce. Moved to the new PGM package: pbmtops (which now produces Conforming PS). Moved to the new PPM package: giftopbm. Moved to the new PNM package: pbmcrop pbmcut pbmenlarge pbminvert. Consolidated into a single pnmflip tool: pbmfliplr pbmfliptb pbmtrnspos. Consolidated into a single pnmcat tool: pbmcatlr pbmcattb. Added compataliases script for upward compatability with changed tools. Removed xxxtopbm. Added a -headersize flag to macptopbm, to help get around annoying problems in MacPaint file format. Added the RAWBITS compilation-time option, to use a more compact and much faster (but less portable) external format. Removed the CBM format - use compress(1) and / or RAWBITS instead. Pbmpaste (and the new pnmpaste) now accepts negative x and y coords, which are interpreted relative to the right and bottom sides. Changed all programs to accept a "-" file argument as meaning standard input. Removed pbmtox10wd, since it was never very useful (X10 doesn't have xwud). Added Imakefiles, for X11 types to use. Changes since the X.V11R3 distribution of 31aug88: The cbm format has been revised to support run-length encoding. Pbmtops now does run-length encoding. Major changes since the X.V11R2 distribution of 28mar88: The pbm format now has a "magic number". New conversion filters: brushtopbm, giftopbm, pbmtolj, pbmtomacp, pbmtoxwd, and pbmtox10wd. Icontopbm converter has a better parser -- it knows to skip over any extraneous comments at the beginning of the icon file. Pbmtops generates a different PostScript wrapper program -- it should handle huge bitmaps better. Xwdtopbm now handles byte-swapping correctly. Pbmmake takes a flag to specify the color of the new bitmap. Pbmpaste now implements 'or', 'and', and 'xor' operations as well as the default 'replace'. netpbm-8.2/Imakefile0100660000076400000000000000265006015241525013502 0ustar bryanhroot/* Imakefile for pbmplus tools. * * Copyright (C) 1991 by Rainer Klute. * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose and without fee is hereby granted, provided * that the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation. This software is provided "as is" without express or * implied warranty. */ #include #define IHaveSubdirs #define PassCDebugFlags 'CDEBUGFLAGS=$(CDEBUGFLAGS)' #if BuildLibTiff SUBDIRS = libtiff pbm pgm ppm pnm #else SUBDIRS = pbm pgm ppm pnm #endif MakeSubdirs($(SUBDIRS)) DependSubdirs($(SUBDIRS)) World:: @echo "" @echo "Building PBMPLUS" @echo "" @date @echo "" $(MAKE) $(MFLAGS) Makefiles $(MAKE) $(MFLAGS) clean $(MAKE) $(MFLAGS) includes $(MAKE) $(MFLAGS) depend $(MAKE) $(MFLAGS) @echo "" @date @echo "" @echo "Full build of PBMPLUS complete." @echo "" Everything:: @echo "" @echo "Rebuilding PBMPLUS" @echo "" @date @echo "" $(MAKE) $(MFLAGS) Makefiles $(MAKE) $(MFLAGS) includes $(MAKE) $(MFLAGS) depend $(MAKE) $(MFLAGS) @echo "" @date @echo "" @echo "Rebuild of PBMPLUS complete." @echo "" realclean: clean @echo "" @echo "Removing Makefiles" @echo "" rm */Makefile Makefile @echo "" #if InstallIncludes InstallMultipleFlags(pbmplus.h,$(PBMPLUSDIR)$(PBMPLUSINCDIR),$(INSTINCFLAGS)) #endif netpbm-8.2/shhopt/0040750000076400000000000000000007065511103013171 5ustar bryanhrootnetpbm-8.2/shhopt/README0100640000076400000000000001166507062132234014061 0ustar bryanhrootshhopt - library for parsing command line options. ================================================== This is a set of functions for parsing command line options. Both traditional one-character options, and GNU-style --long-options are supported. What separates this from traditional getopt? -------------------------------------------- This library does more of the parsing for you. You set up a special structure describing the names and types of the options you want your program to support. In the structure you also give addresses of variables to update or functions to call for the various options. By calling optParseOptions, all options in argv are parsed and removed from argv. What is left, are the non-optional arguments to your program. The down-side of this, is that you won't be able to make a program where the position of the options between the non-options are significant. shhopt is distributed under the "Artistic license" (aka. the Perl license), which IMHO gives more freedom than GPL or LGPL. For a copy of the Artistic license, see http://www.opensource.org/licenses/artistic-license.html For more information on Open Source licenses, go to http://www.opensource.org/licenses/ Usage ----- To see how to use this library, take a look at the sample program example.c. A brief explanation: To parse your command line, you need to create and initialize an array of optStruct's. Each element in the array describes a long and short version of an option and specifies what type of option it is and how to handle it. The structure fields (see also shhopt.h): `shortName' is the short option name without the leading '-'. `longName' is the long option name without the leading "--". `type' specifies what type of option this is. (Does it expect an argument? Is it a flag? If it takes an argument, what type should it be?) `arg' is either a function to be called with the argument from the commandline, or a pointer to a location in which to store the value. `flags' indicates whether `arg' points to a function or a storage location. The different argument types: `OPT_END' flags this as the last element in the options array. `OPT_FLAG' indicates an option that takes no arguments. If `arg' is not a function pointer, the value of `arg' will be set to 1 if this flag is found on the command line. `OPT_STRING' expects a string argument. `OPT_INT' expects an int argument. `OPT_UINT' expects an unsigned int argument. `OPT_LONG' expects a long argument. `OPT_ULONG' expects an unsigned long argument. The different flag types: `OPT_CALLFUNC' indicates that `arg' is a function pointer. If this is not given, `arg' is taken as a pointer to a variable. Notes ----- * A dash (`-') by itself is not taken as any kind of an option, as several programs use this to indicate the special files stdin and stdout. It is thus left as a normal argument to the program. * Two dashes (`--') as an argument, is taken to mean that the rest of the arguments should not be scanned for options. This simplifies giving names of files that start with a dash. * Short (one-character) options accept parameters in two ways, either directly following the option in the same argv-entry, or in the next argv-entry: -sPARAMETER -s PARAMETER * Long options accept parameters in two ways: --long-option=PARAMETER --long-option PARAMETER To follow the GNU-tradition, your program documentation should use the first form. * Several one-character options may be combined after a single dash. If any of the options requires a parameter, the rest of the string is taken as this parameter. If there is no "rest of the string", the next argument is taken as the parameter. * There is no support for floating point (double) arguments to options. This is to avoid unnecessary linking with the math library. See example.c for how to get around this by writing a function converting a string argument to a double (functions strToDouble and doubleFunc). Portability ----------- If your libc lacks strtoul, you will need to link with GNU's -liberty, that may be found by anonymous ftp to ftp://ftp.gnu.org/pub/gnu/ The library has (more or less recently) been compiled and `tested' on the following systems: IRIX Release 5.3 IP22 GNU/Linux 2.2.11 SunOS Release 4.1.3_U1 (-liberty needed) ULTRIX V4.4 (Rev. 69) All compilations were done using GNU's gcc, and GNU's make. Author ------ The program is written by Sverre H. Huseby sverrehu@online.no Lofthusvn. 11 B http://home.sol.no/~sverrehu/ N-0587 Oslo Norway You can use and copy this for _free_, but I would be very happy if you send me an E-mail and tell me that you use it. If you insist on paying something, please donate some money to an organization that strives to make the world a better place for everyone. I don't like bugs, so please help me removing them by reporting whatever you find! netpbm-8.2/shhopt/INSTALL0100640000076400000000000000073006766254520014236 0ustar bryanhrootInstalling shhopt ================= If you don't have gcc, you'll have to edit the Makefile. If your compiler is not ANSI, you'll have to change all files. 1. Check the Makefile 2. Build the library make dep make 3. Install library and header file make install By default, the library will be installed in /usr/local/lib, and the header file in /usr/local/include. If you run Linux with ELF, you may want to make a shared library. Check out the Makefile. netpbm-8.2/shhopt/CREDITS0100640000076400000000000000037507062132545014222 0ustar bryanhrootThanks to (see ChangeLog for details): Andrew C. Feren Your name may appear here too, if you * fix bugs * write an even better documentation * extend the functionality of the library * do something nice * all of the above netpbm-8.2/shhopt/ChangeLog0100640000076400000000000000436507062133015014750 0ustar bryanhroot2000-03-10 Sverre H. Huseby * Release: 1.1.6 * README: Moved license info links from metalab.unc.edu to www.opensource.org. Updated my snail mail address to where I'll live from 2000-04-06 or so. * shhopt.lsm.in (Copying-policy): Pointed to opensource.org for licensing info. * shhopt.h: Removed the trailing comma from the enum, on request from . I always thought this was legal, but after examining the K&R book more thoroughly, it seems it is only legal for array initializers. 1999-09-10 Sverre H. Huseby * Release 1.1.5 * README: Added information on the Artistic license * shhopt.c (optMatch): Made the p variable const, as this compiles more cleanly on Borland's compiler, according to Vladislav Papayan * shhopt.c, example.c: Changed formatting of comments. 1998-07-05 Sverre H. Huseby * Release 1.1.4 * Updated author address. Tue May 27 23:13:19 1997 Sverre H. Huseby * Version: 1.1.3 Sat May 17 21:56:36 1997 Sverre H. Huseby * shhopt.h: Added `extern "C"'. Sun Mar 23 09:47:43 1997 Sverre H. Huseby * Release: 1.1.2 * Makefile: Creating lib*.so in addition to lib*.so.* Tue Nov 12 08:36:09 1996 Sverre H. Huseby * Version: 1.1.1 * shhopt.c: Minor restructuring, no code changes. * example.c: Restructured a bit, and added some comments. Thu Jun 6 10:55:00 1996 Sverre H. Huseby * Released version 1.1. * Makefile: Added example.o to the dependecy list of example. * README: Pointer to the double parsing in example.c * example.c: Added parsing of parameter taking a double value. Thu Jun 6 01:38:00 1996 Sverre H. Huseby * Released version 1.0. * Included patches from Andrew. * Did some minor cosmetic changes. Wed May 22 15:05:00 1996 Andrew C. Feren * Makefile: Changed from "ar rcs" to "ar rc" & ranlib. * README: Improved the documentation. * shhopt.c: Fixed bug for arguments of type unsigned int. Fri Mar 15 15:00:30 1996 Sverre H. Huseby * Released first BETA version: 0.1 netpbm-8.2/shhopt/Makefile0100640000076400000000000000501207062133037014630 0ustar bryanhroot# $Id: Makefile,v 1.10 2000/03/10 08:45:19 sverrehu Exp $ DIST = shhopt VERMAJ = 1 VERMIN = 1 VERPAT = 6 VERSION = $(VERMAJ).$(VERMIN).$(VERPAT) # Define SHARED as 1 for Linux shared ELF library #SHARED = 1 ifeq ($(SHARED),1) LIBTARGET = lib$(DIST).so.$(VERSION) LIBTARGETSO = lib$(DIST).so LIBTARGETSOMAJ = $(LIBTARGETSO).$(VERMAJ) CCSHRD = -fPIC else LIBTARGET = lib$(DIST).a endif LIBHEAD = $(DIST).h TARGETS = $(LIBTARGET) INSTBASEDIR = /usr/local INSTLIBDIR = $(INSTBASEDIR)/lib INSTINCDIR = $(INSTBASEDIR)/include INSTALL = install -m 644 INSTALLPROG = install -m 755 MKDIRP = install -d -m 755 CC = gcc OPTIM = -O2 INCDIR = -I. CCOPT = -s -Wall $(OPTIM) $(INCDIR) # Object files to store in the library LIBOBJS = shhopt.o all: $(TARGETS) # don't worry if you get ranlib not found errors. This probably means # that your ar does an implicit ranlib and you do not need to run ranlib # separately. This error is harmless. $(LIBTARGET): $(LIBOBJS) ifeq ($(SHARED),1) $(CC) -shared -Wl,-soname,$(LIBTARGETSOMAJ) -o $(LIBTARGET) $(LIBOBJS) else ar rc $(LIBTARGET) $(LIBOBJS) ranlib $(LIBTARGET) || true endif # Note that you may need GNU's -liberty if your libc lacks strtoul example: $(LIBTARGET) example.o $(CC) -o example example.c \ -L. -I. -L$(INSTLIBDIR) -I$(INSTINCDIR) -lshhopt .c.o: $(CC) $(CCSHRD) -o $@ -c $(CCOPT) $< depend dep: $(CC) $(INCDIR) -MM *.c >depend install: $(LIBTARGET) $(MKDIRP) $(INSTLIBDIR) $(INSTINCDIR) $(INSTALL) $(LIBTARGET) $(INSTLIBDIR) $(INSTALL) $(LIBHEAD) $(INSTINCDIR) ifeq ($(SHARED),1) ln -sf $(LIBTARGET) $(INSTLIBDIR)/$(LIBTARGETSOMAJ) ln -sf $(LIBTARGETSOMAJ) $(INSTLIBDIR)/$(LIBTARGETSO) echo "If you use GNU/Linux, remember to run ldconfig" endif clean: rm -f *.o core *~ depend chmod: chmod a+r * # To let the author make a distribution. The rest of the Makefile # should be used by the author only. LSMFILE = $(DIST)-$(VERSION).lsm DISTDIR = $(DIST)-$(VERSION) DISTFILE = $(DIST)-$(VERSION).tar.gz DISTFILES = README INSTALL CREDITS ChangeLog \ Makefile $(LSMFILE) \ $(LIBHEAD) \ shhopt.c \ example.c $(LSMFILE): $(DIST).lsm.in VER=$(VERSION); \ DATE=`date "+%d%b%y"|tr '[a-z]' '[A-Z]'`; \ sed -e "s/VER/$$VER/g;s/DATE/$$DATE/g" $(DIST).lsm.in > $(LSMFILE) veryclean: clean rm -f $(TARGETS) $(DISTFILE) $(LSMFILE) example dist: $(LSMFILE) chmod mkdir $(DISTDIR) chmod a+rx $(DISTDIR) ln $(DISTFILES) $(DISTDIR) tar -cvzf $(DISTFILE) $(DISTDIR) chmod a+r $(DISTFILE) rm -rf $(DISTDIR) ifeq (depend,$(wildcard depend)) include depend endif netpbm-8.2/shhopt/shhopt-1.1.6.lsm0100640000076400000000000000115707062133050015654 0ustar bryanhrootBegin3 Title: shhopt - library for parsing command line options. Version: 1.1.6 Entered-date: 10MAR00 Description: C-functions for parsing command line options, both traditional one-character options, and GNU'ish --long-options. Keywords: programming, library, lib, commandline, options Author: sverrehu@online.no (Sverre H. Huseby) Primary-site: http://home.sol.no/~sverrehu/pub-unix/ Alternate-site: sunsite.unc.edu /pub/Linux/libs shhopt-1.1.6.tar.gz Platforms: Requires ANSI C-compiler. Copying-policy: Artistic License http://www.opensource.org/licenses/artistic-license.html End netpbm-8.2/shhopt/shhopt.h0100640000076400000000000000250407062131447014654 0ustar bryanhroot/* $Id: shhopt.h,v 1.5 2000/03/10 08:32:39 sverrehu Exp $ */ #ifndef SHHOPT_H #define SHHOPT_H #ifdef __cplusplus extern "C" { #endif /* constants for recognized option types. */ typedef enum { OPT_END, /* nothing. used as ending element. */ OPT_FLAG, /* no argument following. sets variable to 1. */ OPT_STRING, /* string argument. */ OPT_INT, /* signed integer argument. */ OPT_UINT, /* unsigned integer argument. */ OPT_LONG, /* signed long integer argument. */ OPT_ULONG /* unsigned long integer argument. */ } optArgType; /* flags modifying the default way options are handeled. */ #define OPT_CALLFUNC 1 /* pass argument to a function. */ typedef struct { char shortName; /* short option name. */ char *longName; /* long option name, no including '--'. */ optArgType type; /* option type. */ void *arg; /* pointer to variable to fill with argument, * or pointer to function if type == OPT_FUNC. */ int flags; /* modifier flags. */ } optStruct; void optSetFatalFunc(void (*f)(const char *, ...)); void optParseOptions(int *argc, char *argv[], optStruct opt[], int allowNegNum); #ifdef __cplusplus } #endif #endif netpbm-8.2/shhopt/shhopt.c0100640000076400000000000003001506766254724014663 0ustar bryanhroot/* $Id: shhopt.c,v 1.5 1999/09/10 19:19:48 sverrehu Exp $ */ /*------------------------------------------------------------------------ | FILE shhopt.c | | DESCRIPTION Functions for parsing command line arguments. Values | of miscellaneous types may be stored in variables, | or passed to functions as specified. | | REQUIREMENTS Some systems lack the ANSI C -function strtoul. If your | system is one of those, you'll ned to write one yourself, | or get the GNU liberty-library (from prep.ai.mit.edu). | | WRITTEN BY Sverre H. Huseby +----------------------------------------------------------------------*/ #include #include #include #include #include #include #include #include "shhopt.h" /*-----------------------------------------------------------------------+ | PRIVATE DATA | +-----------------------------------------------------------------------*/ static void optFatalFunc(const char *, ...); static void (*optFatal)(const char *format, ...) = optFatalFunc; /*-----------------------------------------------------------------------+ | PRIVATE FUNCTIONS | +-----------------------------------------------------------------------*/ /*------------------------------------------------------------------------ | NAME optFatalFunc | | FUNCTION Show given message and abort the program. | | INPUT format, ... | Arguments used as with printf(). | | RETURNS Never returns. The program is aborted. */ void optFatalFunc(const char *format, ...) { va_list ap; fflush(stdout); va_start(ap, format); vfprintf(stderr, format, ap); va_end(ap); exit(99); } /*------------------------------------------------------------------------ | NAME optStructCount | | FUNCTION Get number of options in a optStruct. | | INPUT opt array of possible options. | | RETURNS Number of options in the given array. | | DESCRIPTION Count elements in an optStruct-array. The strcture must | be ended using an element of type OPT_END. */ static int optStructCount(optStruct opt[]) { int ret = 0; while (opt[ret].type != OPT_END) ++ret; return ret; } /*------------------------------------------------------------------------ | NAME optMatch | | FUNCTION Find a matching option. | | INPUT opt array of possible options. | s string to match, without `-' or `--'. | lng match long option, otherwise short. | | RETURNS Index to the option if found, -1 if not found. | | DESCRIPTION Short options are matched from the first character in | the given string. */ static int optMatch(optStruct opt[], const char *s, int lng) { int nopt, q, matchlen = 0; const char *p; nopt = optStructCount(opt); if (lng) { if ((p = strchr(s, '=')) != NULL) matchlen = p - s; else matchlen = strlen(s); } for (q = 0; q < nopt; q++) { if (lng) { if (!opt[q].longName) continue; if (strncmp(s, opt[q].longName, matchlen) == 0) return q; } else { if (!opt[q].shortName) continue; if (*s == opt[q].shortName) return q; } } return -1; } /*------------------------------------------------------------------------ | NAME optString | | FUNCTION Return a (static) string with the option name. | | INPUT opt the option to stringify. | lng is it a long option? | | RETURNS Pointer to static string. */ static char * optString(optStruct *opt, int lng) { static char ret[31]; if (lng) { strcpy(ret, "--"); strncpy(ret + 2, opt->longName, 28); } else { ret[0] = '-'; ret[1] = opt->shortName; ret[2] = '\0'; } return ret; } /*------------------------------------------------------------------------ | NAME optNeedsArgument | | FUNCTION Check if an option requires an argument. | | INPUT opt the option to check. | | RETURNS Boolean value. */ static int optNeedsArgument(optStruct *opt) { return opt->type == OPT_STRING || opt->type == OPT_INT || opt->type == OPT_UINT || opt->type == OPT_LONG || opt->type == OPT_ULONG; } /*------------------------------------------------------------------------ | NAME argvRemove | | FUNCTION Remove an entry from an argv-array. | | INPUT argc pointer to number of options. | argv array of option-/argument-strings. | i index of option to remove. | | OUTPUT argc new argument count. | argv array with given argument removed. */ static void argvRemove(int *argc, char *argv[], int i) { if (i >= *argc) return; while (i++ < *argc) argv[i - 1] = argv[i]; --*argc; } /*------------------------------------------------------------------------ | NAME optExecute | | FUNCTION Perform the action of an option. | | INPUT opt array of possible options. | arg argument to option, if it applies. | lng was the option given as a long option? | | RETURNS Nothing. Aborts in case of error. */ void optExecute(optStruct *opt, char *arg, int lng) { switch (opt->type) { case OPT_FLAG: if (opt->flags & OPT_CALLFUNC) ((void (*)(void)) opt->arg)(); else *((int *) opt->arg) = 1; break; case OPT_STRING: if (opt->flags & OPT_CALLFUNC) ((void (*)(char *)) opt->arg)(arg); else *((char **) opt->arg) = arg; break; case OPT_INT: case OPT_LONG: { long tmp; char *e; tmp = strtol(arg, &e, 10); if (*e) optFatal("invalid number `%s'\n", arg); if (errno == ERANGE || (opt->type == OPT_INT && (tmp > INT_MAX || tmp < INT_MIN))) optFatal("number `%s' to `%s' out of range\n", arg, optString(opt, lng)); if (opt->type == OPT_INT) { if (opt->flags & OPT_CALLFUNC) ((void (*)(int)) opt->arg)((int) tmp); else *((int *) opt->arg) = (int) tmp; } else /* OPT_LONG */ { if (opt->flags & OPT_CALLFUNC) ((void (*)(long)) opt->arg)(tmp); else *((long *) opt->arg) = tmp; } break; } case OPT_UINT: case OPT_ULONG: { unsigned long tmp; char *e; tmp = strtoul(arg, &e, 10); if (*e) optFatal("invalid number `%s'\n", arg); if (errno == ERANGE || (opt->type == OPT_UINT && tmp > UINT_MAX)) optFatal("number `%s' to `%s' out of range\n", arg, optString(opt, lng)); if (opt->type == OPT_UINT) { if (opt->flags & OPT_CALLFUNC) ((void (*)(unsigned)) opt->arg)((unsigned) tmp); else *((unsigned *) opt->arg) = (unsigned) tmp; } else /* OPT_ULONG */ { if (opt->flags & OPT_CALLFUNC) ((void (*)(unsigned long)) opt->arg)(tmp); else *((unsigned long *) opt->arg) = tmp; } break; } default: break; } } /*-----------------------------------------------------------------------+ | PUBLIC FUNCTIONS | +-----------------------------------------------------------------------*/ /*------------------------------------------------------------------------ | NAME optSetFatalFunc | | FUNCTION Set function used to display error message and exit. | | SYNOPSIS #include "shhopt.h" | void optSetFatalFunc(void (*f)(const char *, ...)); | | INPUT f function accepting printf()'like parameters, | that _must_ abort the program. */ void optSetFatalFunc(void (*f)(const char *, ...)) { optFatal = f; } /*------------------------------------------------------------------------ | NAME optParseOptions | | FUNCTION Parse commandline options. | | SYNOPSIS #include "shhopt.h" | void optParseOptions(int *argc, char *argv[], | optStruct opt[], int allowNegNum); | | INPUT argc Pointer to number of options. | argv Array of option-/argument-strings. | opt Array of possible options. | allowNegNum | a negative number is not to be taken as | an option. | | OUTPUT argc new argument count. | argv array with arguments removed. | | RETURNS Nothing. Aborts in case of error. | | DESCRIPTION This function checks each option in the argv-array | against strings in the opt-array, and `executes' any | matching action. Any arguments to the options are | extracted and stored in the variables or passed to | functions pointed to by entries in opt. | | Options and arguments used are removed from the argv- | array, and argc is decreased accordingly. | | Any error leads to program abortion. */ void optParseOptions(int *argc, char *argv[], optStruct opt[], int allowNegNum) { int ai, /* argv index. */ optarg, /* argv index of option argument, or -1 if none. */ mi, /* Match index in opt. */ done; char *arg, /* Pointer to argument to an option. */ *o, /* pointer to an option character */ *p; /* * Loop through all arguments. */ for (ai = 0; ai < *argc; ) { /* * "--" indicates that the rest of the argv-array does not * contain options. */ if (strcmp(argv[ai], "--") == 0) { argvRemove(argc, argv, ai); break; } if (allowNegNum && argv[ai][0] == '-' && isdigit(argv[ai][1])) { ++ai; continue; } else if (strncmp(argv[ai], "--", 2) == 0) { /* long option */ /* find matching option */ if ((mi = optMatch(opt, argv[ai] + 2, 1)) < 0) optFatal("unrecognized option `%s'\n", argv[ai]); /* possibly locate the argument to this option. */ arg = NULL; if ((p = strchr(argv[ai], '=')) != NULL) arg = p + 1; /* does this option take an argument? */ optarg = -1; if (optNeedsArgument(&opt[mi])) { /* option needs an argument. find it. */ if (!arg) { if ((optarg = ai + 1) == *argc) optFatal("option `%s' requires an argument\n", optString(&opt[mi], 1)); arg = argv[optarg]; } } else { if (arg) optFatal("option `%s' doesn't allow an argument\n", optString(&opt[mi], 1)); } /* perform the action of this option. */ optExecute(&opt[mi], arg, 1); /* remove option and any argument from the argv-array. */ if (optarg >= 0) argvRemove(argc, argv, ai); argvRemove(argc, argv, ai); } else if (*argv[ai] == '-') { /* A dash by itself is not considered an option. */ if (argv[ai][1] == '\0') { ++ai; continue; } /* Short option(s) following */ o = argv[ai] + 1; done = 0; optarg = -1; while (*o && !done) { /* find matching option */ if ((mi = optMatch(opt, o, 0)) < 0) optFatal("unrecognized option `-%c'\n", *o); /* does this option take an argument? */ optarg = -1; arg = NULL; if (optNeedsArgument(&opt[mi])) { /* option needs an argument. find it. */ arg = o + 1; if (!*arg) { if ((optarg = ai + 1) == *argc) optFatal("option `%s' requires an argument\n", optString(&opt[mi], 0)); arg = argv[optarg]; } done = 1; } /* perform the action of this option. */ optExecute(&opt[mi], arg, 0); ++o; } /* remove option and any argument from the argv-array. */ if (optarg >= 0) argvRemove(argc, argv, ai); argvRemove(argc, argv, ai); } else { /* a non-option argument */ ++ai; } } } netpbm-8.2/shhopt/example.c0100640000076400000000000001046706766254724015022 0ustar bryanhroot/* $Id: example.c,v 1.6 1999/09/10 19:19:48 sverrehu Exp $ */ /*------------------------------------------------------------------------ | FILE example.c | | DESCRIPTION Sample source code using the shhopt-library to parse | command line options. | | WRITTEN BY Sverre H. Huseby +----------------------------------------------------------------------*/ #include #include #include /* needed in strToDouble only */ #include "shhopt.h" /*-----------------------------------------------------------------------+ | PRIVATE DATA | +-----------------------------------------------------------------------*/ /* called by -N or --number-func */ static void numberFunc(int i) { printf("integer function called, i=%d\n", i); } /* called by -S or --string-func */ static void stringFunc(char *s) { printf("string function called, s=\"%s\"\n", s); } /* called by -F or --flag-func */ static void flagFunc(void) { printf("flag function called\n"); } /* shhopt does not support double arguments, so we write our own * handler for this. The trick is to create a function taking a string * argument, and convert this string to a double. The following two * functions handles this. */ /* convert a string to a double value, with error checking */ static double strToDouble(char *s) { double d; char *e; d = strtod(s, &e); if (*e) { fprintf(stderr, "invalid number `%s'\n", s); exit(1); } if (errno == ERANGE) { fprintf(stderr, "number `%s' out of range\n", s); exit(1); } return d; } /* called by -D or --double-func */ static void doubleFunc(char *s) { double d; d = strToDouble(s); printf("double function called, d=\"%g\"\n", d); } static void usage(void) { printf( "usage: example [option ...] [other-arguments ...]\n" "\n" " -n, --number=NUMBER set value of variable `number'\n" " -N, --number-func=NUMBER call function with given integer argument\n" " -D, --double-func=NUMBER call function with given double argument\n" " -s, --string=STRING set value of variable `string'\n" " -S, --string-func=STRING call function with given string argument\n" " -f, --flag set value of variable `flag' to 1\n" " -F, --flag-func call a function with no argument\n" "\n" "A double-dash (`--') indicates that the rest of the line is not to\n" "be scanned for options.\n" ); exit(1); } /*-----------------------------------------------------------------------+ | PUBLIC FUNCTIONS | +-----------------------------------------------------------------------*/ int main(int argc, char *argv[]) { int q; /* counter */ int number = 0; /* set to anything by -n or --number */ int flag = 0; /* set to 1 by -f or --flag */ char *string = "none"; /* set to anything by -s or --string */ optStruct opt[] = { /* short long type var/func special */ { 'h', "help", OPT_FLAG, usage, OPT_CALLFUNC }, { 'n', "number", OPT_INT, &number, 0 }, { 'N', "number-func", OPT_INT, numberFunc, OPT_CALLFUNC }, { 'D', "double-func", OPT_STRING, doubleFunc, OPT_CALLFUNC }, { 's', "string", OPT_STRING, &string, 0 }, { 'S', "string-func", OPT_STRING, stringFunc, OPT_CALLFUNC }, { 'f', "flag", OPT_FLAG, &flag, 0 }, { 'F', "flag-func", OPT_FLAG, flagFunc, OPT_CALLFUNC }, { 0, 0, OPT_END, 0, 0 } /* no more options */ }; /* if you link with the shhmsg-library, you may wish to set the * the error handling function by calling * optSetFatalFunc(msgFatal); */ /* parse all options */ optParseOptions(&argc, argv, opt, 0); /* display result */ printf("number=%d, flag=%d, string=\"%s\"\n", number, flag, string); /* what's left in argv, are any non-optinons. */ printf("remaining arguments: "); for (q = 1; q < argc; q++) printf("\"%s\" ", argv[q]); printf("\n"); return 0; } netpbm-8.2/shhopt/libshhopt.a0100660000076400000000000000737007062232274015344 0ustar bryanhroot! / 952710332 0 0 0 60 ` optExecuteoptSetFatalFuncoptParseOptionsshhopt.o/ 952710331 500 0 100660 3644 ` ELF4( US]hE PShjc'UM1yt 1҃@|u]ÐUWVS1URE}t4j=U Rt+} &0} Ѝx19]~O1v}t*UD2t0WPU R u('U2tU 8tC9]e[^_]Í&UU} t4ffjBPh v'-]ÐUE1ɋPBv Bvuȉ]Ðt&UWVS}u M9~AʉDBA9|Ke[^_]Ív'UWVS]} CHI$'0Ppp&Ct C C Ct Wt&C 8Ejj PWƃE8tWhЃ="uURSbPWhЃCury'Ejj PWƃE8tWhЃ="t {u't&URSPWhЃ{tCt VC C 0e[^_]ÐUE]ÐUWVSEMU9 U UM1u$URM QURc&'}t*M8-u PDPtMt&jhUP jMPUR/E }MPh:Ѓ1j=UPtpEMUSt7uOMAMU9 ujS}PhTЃMU 4tjSTPhvЃjVMUP &M8-xu MXEjSUR(E }PhЃE1MUPGN_Xp+i6toP`shhopt.cgcc2_compiled.optFataloptFatalFuncoptStructCountoptMatchret.40optStringoptNeedsArgumentargvRemove_IO_stdout_fflush_IO_stderr_vfprintfexitstrchrstrncmpstrncpyoptExecute__strtol_internalerrno__strtoul_internaloptSetFatalFuncoptParseOptions__ctype_b #w $* 0;@R[ag $z    "W  2 7K  7 < netpbm-8.2/Makefile0100660000076400000000000001406207065336763013350 0ustar bryanhroot# Makefile for pbmplus tools. # # Copyright (C) 1989, 1991 by Jef Poskanzer. # # Permission to use, copy, modify, and distribute this software and its # documentation for any purpose and without fee is hereby granted, provided # that the above copyright notice appear in all copies and that both that # copyright notice and this permission notice appear in supporting # documentation. This software is provided "as is" without express or # implied warranty. # CONFIGURE: Normally the Makefiles build and install separate binaries for # each program. However, on some systems (especially those without shared # libraries) this can mean a lot of space. In this case you might try # building a "merge" instead. The idea here is to link all the binaries # together into one huge executable, with a tiny dispatch program as the # main. Then the merged binary is installed with file-system links for # each program it includes. The dispatch routine can tell which program # to run by looking at argv[0]. On a Sun3 under SunOS 3.5 the space for # executables went from 2.9 meg to .36 meg. # # To build a "merge" system, do a "make merge" instead of "make [all]" # and "make install-merge" instead of "make install". #CC = cc #CC = gcc #CC = gcc -fpcc-struct-return CC = gcc -pedantic -fpcc-struct-return # CONFIGURE: cc flags go here. #CDEBUG is for setting on the command line to temporarily add an additional #compiler option. E.g. make all CDEBUG=-g or make CDEBUG=-Werror CFLAGS = -O2 -Wall -Wno-uninitialized $(TIFFDEF) $(CDEBUG) # CONFIGURE: ld flags go here. Eunice users may want to use -noshare so that # the binaries can run standalone. LDFLAGS = -s #LDFLAGS = #LDFLAGS = -noshare # CONFIGURE: The netpbm package contains a version of the Tiff library, # libtiff. If you want to use your own, fill in the appropriate paths # below for the library and its interface headers # These paths are relative to one of our subdirectories. These variables are # used only in subdirectory make files. TIFFINC = -I../libtiff TIFFLIB = ../libtiff/libtiff.a TIFFDEF = -DLIBTIFF # CONFIGURE: If you want to build the jpeg converters or tiff # converters that use jpeg compression in tiff files, you must have # the jpeg library already installed. Put the locations of the link # library and the interface header files here. If you do not have the # JPEG library, and still want to successully build everything else, # including non-JPEG versions of the tiff converters, put NONE for # these. # Special note for people using an already-installed Tiff library: If # your library was built with the JPEG stuff statically linked in, you # don't need the JPEG library and the tiff converters will still do jpeg. # If your library references a dynamic JPEG library, you must specify # at least JPEGLIB_DIR here, or the tiff converters will not build at # all. JPEGLIB_DIR = /usr/lib/jpeg JPEGHDR_DIR = /usr/include/jpeg # CONFIGURE: Specify the directory where you want the executables. # If you need scripts and binaries to be in different directories, you # can set that up too. INSTALLBINARIES = /usr/local/netpbm INSTALLSCRIPTS = $(INSTALLBINARIES) # CONFIGURE: Specify the directory where you want the shared libraries # installed. For this to be effective, you must have set up this location # to be searched by your system's program executor for runtime libraries. INSTALLLIBS = $(INSTALLBINARIES) # CONFIGURE: Specify the directories that you want the manual sources copied to, # plus the suffix you want them to have. INSTALLMANUALS1 = /usr/local/man/man1 SUFFIXMANUALS1 = 1 INSTALLMANUALS3 = /usr/local/man/man3 SUFFIXMANUALS3 = 3 INSTALLMANUALS5 = /usr/local/man/man5 SUFFIXMANUALS5 = 5 # CONFIGURE: Normally the man pages are installed using "cp". By changing # this define you can use something else, for example a script that calls # compress or pack. The ../mantocat is used on systems which use man pages # in the "cat" format. MANCP = cp #MANCP = ../mantocat # End of configurable definitions. SHELL = /bin/sh MAKE = make SUBDIRS = pbm pgm ppm pnm MAKE_OVERRIDES = 'CC=$(CC)' 'CFLAGS=$(CFLAGS)' 'TIFFDEF=$(TIFFDEF)' 'TIFFINC=$(TIFFINC)' 'TIFFLIB=$(TIFFLIB)' 'LDFLAGS=$(LDFLAGS)' # Note that the Tiff library, from the libtiff subdirectory only gets built # if you specify the homegrown libtiff as $(TIFFLIB), in which case it is # a dependency of stuff in the pnm subdirectory. Or you can cd to the # libtiff subdirectory and do a "make all" there. .PHONY: all all: compile.h $(SUBDIRS) .PHONY: libtiff libtiff: $(MAKE) -C $@ all .PHONY: $(SUBDIRS) $(SUBDIRS): $(MAKE) -C $@ $(MAKE_OVERRIDES) all # Note that we create a new compile.h only for the first make after a # make clean. This is good enough. We used to do stamp-date for every # build of "all" from this make file, but nowhere else, so it was really # sloppy. compile.h: ./stamp-date .PHONY: install install: install.bin install.lib install.man .PHONY: merge merge: ./stamp-date ( echo "libtiff" ; cd libtiff ; make ) for i in $(SUBDIRS) ; do \ ( echo $$i ; cd $$i ; $(MAKE) $(MFLAGS) $(MAKE_OVERRIDES) merge );\ done .PHONY: install.bin install.bin: -mkdir $(INSTALLBINARIES) for i in $(SUBDIRS) ; do \ ( echo $$i ; cd $$i ; $(MAKE) $(MFLAGS) $(MAKE_OVERRIDES) \ install.bin ); \ done .PHONY: install-merge install.merge: -mkdir $(INSTALLBINARIES) for i in $(SUBDIRS) ; do \ ( echo $$i ; cd $$i ; $(MAKE) $(MFLAGS) $(MAKE_OVERRIDES) \ install.merge ); \ done .PHONY: install.lib install.lib: for i in $(SUBDIRS) ; do \ ( echo $$i ; cd $$i ; $(MAKE) $(MFLAGS) $(MAKE_OVERRIDES) \ install.lib ); \ done cd libtiff; $(MAKE) install .PHONY: install.man install.man: for i in $(SUBDIRS) ; do \ ( echo $$i ; cd $$i ; $(MAKE) $(MFLAGS) $(MAKE_OVERRIDES) \ install.man ); \ done .PHONY: clean clean: rm -f *.shar *.shar? art.* *~ rm -f compile.h for i in $(SUBDIRS) libtiff shhopt ; do \ ( echo $$i ; cd $$i ; $(MAKE) $(MFLAGS) $(MAKE_OVERRIDES) clean ); \ done .PHONY: dep dep: for i in $(SUBDIRS) libtiff ; do \ ( echo $$i ; cd $$i ; $(MAKE) $(MFLAGS) $(MAKE_OVERRIDES) dep ); \ done netpbm-8.2/Netpbm.programming0100660000076400000000000000540505471651023015366 0ustar bryanhrootThis file is an attempt to give some basic guide lines for those who wish to write new Netpbm filters. Since Netpbm is intended to be portable to many platforms, it is absolutely necessary to stick to these when programming. Most of these rules were set up by Jef Poskanzer when he wrote Pbmplus, though some have come up more recently. * Your new filter must belong to one of the four Netpbm formats, i.e. pbm, pgm, ppm or pnm. They are defined as follows: pbm: Bitmaps only, i.e. a pixel is either black or white. pgm: Gray scales, i.e. a pixel can have any value between black and white, but no colours. ppm: Colour images. Note that Netpbm does not support the use of look up tables. pnm: A facility able to create or read more than one of the formats above. Note that all pgm filters can automatically read pbm images, and that all ppm filters can automatically read both pbm and pgm files. A pnm utility does more than this, its action depends on the type of the input file. E.g. the pnmtotiff utility creates a bitmap TIFF file when it reads a pbm file on its input, a gray scale TIFF files when it reads a pgm file on its input, etc. ppmtogif on the other hand treats a pbm file on its input exactly as if it were a ppm file with only the colours black and white. Decide which one of these formats your filter belongs to. * If you want to use global variables or global functions in your filter, make them static, so that they won't cause problems to other filters when you compile a merged binary (see the Makefile). * So far, all filters are written in K&R style C, but with prototypes for both K&R C and ANSI C. The ARGS macro (defined in pbmplus.h) helps you to write prototypes. You can use it like this: int my_function ARGS((int a, double b, char c)); * Include pbm.h, pgm.h, ppm.h, or pnm.h (only one of them!). Don't include files like stdio.h, stdlib.h etc. These should be included through pbmplus.h, which in turn is included by p?m.h (i.e. pbm.h, pgm.h, ppm.h, or pnm.h). You may need to include math.h though. * Declare main as: int main(argc, argv), not void! VMS won't compile void main(). * Always start the code in main() with a call to p?m_init(). * All input and output of pbm format files must go through the library routines. This ensures compatibility, error checking, correct byte order etc. * Use pm_error() and pm_message() for error messages and other messages. * Don't forget to write a proper manual page! The easiest way to write your own facility, is to take an existing one, similar to the want you want to write, and to modify it. This saves a lot of time, and ensures conformity with the rules stated above. Oliver Trepte, November 15th, 1993 oliver@fysik4.kth.se netpbm-8.2/netpbm-8.2.lsm0100640000076400000000000000152507065340620014200 0ustar bryanhrootBegin4 Title: netpbm: collection of graphics file converters Version: 8.2 Entered-date: 2000-03-20 Description: A whole bunch of utilities for converting from one graphics format to another. For example, from g3 fax format to gif. Also, many basic graphics editing tools such as magnifying and cropping. This is a successor to Jef Poskanzer's PBMPlus package, and gathers converters by many people from many places. Keywords: pbm, pbmplus, netpbm, graphics, converter, conversion, bitmap, pnm, ppm, pgm Author: various Maintained-by: bryanh@giraffe-data.com (Bryan Henderson) Primary-site: metalab.unc.edu /pub/Linux/apps/graphics/convert/netpbm-8.2.tgz Platforms: Any unix-like system Copying-policy: GPL End netpbm-8.2/Pbmplus.tmpl0100660000076400000000000001566506015267507014233 0ustar bryanhroot/* Imake template and rules for PBMPLUS * * Copyright (C) 1991 Rainer Klute * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the copyright holder's name not be used in * advertising or publicity pertaining to distribution of the software * without specific, written prior permission. The copyright holder makes * no representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. */ /* Set where to install PbmPLus */ BINDIR = /usr/X11R6/pbmplus MANDIR = /usr/X11R6/man MANSUFFIX = 1p /* CONFIGURE: PBMPLUS's support for TIFF files depends on the library from * Sam Leffler's TIFF Software package - see the OTHER.SYSTEMS file for a * full description and access information. To configure PBMPLUS to use the * library: first, if necessary, fetch the TIFF Software, unpack it in a * scratch directory somewhere, and move the libtiff subdirectory right here * into the PBMPLUS top-level directory. Then move the file Imakefile.tiff * to libtiff/Imakefile. * * Libtiff is pretty good about portability, but there are some machines * it has problems on. If you run into problems, you may wish to contact * Sam directly, at the address listed in the OTHER.SYSTEMS file. * * By the way, you must have at least version 2.4 of libtiff. Earlier * versions will not work. */ #ifndef BuildLibTiff #define BuildLibTiff YES #endif /* CONFIGURE: You may edit the symbol definitions below as you see fit, * e.g. change the definition of "InstallLibraries" and "InstallIncludes" * to "YES" if you want to have the libraries and include files installed. */ #ifndef InstallBinaries #define InstallBinaries YES #endif #ifndef InstallManuals #define InstallManuals YES #endif #ifndef InstallLibraries #define InstallLibraries NO #endif #ifndef InstallIncludes #define InstallIncludes NO #endif /* CONFIGURE: Normally the Imakefiles build and install separate binaries for * each program. However, on some systems (especially those without shared * libraries) this can mean a lot of space. In this case you might try * building a "merge" instead. The idea here is to link all the binaries * together into one huge executable, with a tiny dispatch program as the * main. Then the merged binary is installed with file-system links for * each program it includes. The dispatch routine can tell which program * to run by looking at argv[0]. On a Sun3 under SunOS 3.5 the space for * executables went from 2.9 meg to .36 meg. * * Note that if you make a "merge", the executables don't get created * until you do the install. */ #ifndef InstallMerged #define InstallMerged NO #endif /* CONFIGURE: Where to install PBMPLUS (defaults to the X11 directories). */ #ifndef PbmplusDir #define PbmplusDir /* defaults to nothing */ #endif #ifndef PbmplusBinDir #define PbmplusBinDir $(BINDIR) #endif #ifndef PbmplusManDir #define PbmplusManDir $(MANDIR) #endif #ifndef PbmplusLibDir #define PbmplusLibDir $(USRLIBDIR) #endif #ifndef PbmplusIncDir #define PbmplusIncDir $(INCDIR) #endif /* End of configurable definitions. */ /* Subdirectories: */ #ifndef PbmDir #define PbmDir TOPDIR/pbm #endif #ifndef PgmDir #define PgmDir TOPDIR/pgm #endif #ifndef PpmDir #define PpmDir TOPDIR/ppm #endif #ifndef PnmDir #define PnmDir TOPDIR/pnm #endif #ifndef TiffDir #define TiffDir TOPDIR/libtiff #endif /* Libraries: */ #ifndef LibPbm #define LibPbm $(PBMDIR)/libpbm.a #endif #ifndef LibPgm #define LibPgm $(PGMDIR)/libpgm.a #endif #ifndef LibPpm #define LibPpm $(PPMDIR)/libppm.a #endif #ifndef LibPnm #define LibPnm $(PNMDIR)/libpnm.a #endif #ifndef LibTiff #define LibTiff $(TIFFDIR)/libtiff.a #endif /* Dependency libraries: */ #ifndef DepLibPbm #define DepLibPbm LibPbm #endif #ifndef DepLibPgm #define DepLibPgm LibPgm #endif #ifndef DepLibPpm #define DepLibPpm LibPpm #endif #ifndef DepLibPnm #define DepLibPnm LibPnm #endif #ifndef DepLibTiff #define DepLibTiff LibTiff #endif PBMPLUSDIR = PbmplusDir PBMPLUSBINDIR = PbmplusBinDir PBMPLUSMANDIR = PbmplusManDir PBMPLUSLIBDIR = PbmplusLibDir PBMPLUSINCDIR = PbmplusIncDir PBMDIR = PbmDir PGMDIR = PgmDir PPMDIR = PpmDir PNMDIR = PnmDir TIFFDIR = TiffDir LIBPBM = LibPbm LIBPGM = LibPgm LIBPPM = LibPpm LIBPNM = LibPnm LIBTIFF = LibTiff DEPLIBPBM = DepLibPbm DEPLIBPGM = DepLibPgm DEPLIBPPM = DepLibPpm DEPLIBPNM = DepLibPnm DEPLIBTIFF = DepLibTiff #if InstallMerged #ifndef InstallPbmplusPrograms #define InstallPbmplusPrograms(list,dest,flags) @@\ install:: list @@\ MakeDir($(DESTDIR)dest) @@\ stamp-date @@\ @case '${MFLAGS}' in *[i]*) set +e;; esac; \ @@\ for i in list; do \ @@\ (set -x; cd $(DESTDIR)dest; $(RM) $$i; \ @@\ $(LN) $(MERGE) $$i); \ @@\ done #endif /* InstallPbmplusPrograms */ #ifndef NormalPbmplusProgramTarget #define NormalPbmplusProgramTarget(program) @@\ program.o: program.c @@\ ObjectCompile("-Dmain=$*_main") @@\ LinkFile(program,$(MERGE)) #endif /* NormalPbmplusProgramTarget */ #ifndef NormalPbmplusMathProgramTarget #define NormalPbmplusMathProgramTarget(program) \ @@\ NormalPbmplusProgramTarget(program) #endif /* NormalPbmplusMathProgramTarget */ #else #ifndef NormalPbmplusProgramTarget #define NormalPbmplusProgramTarget(program) \ @@\ NormalProgramTarget(program,program.o,$(CURRENTDEPLIBS),$(CURRENTLIBS),) #endif /* NormalPbmplusProgramTarget */ #ifndef NormalPbmplusMathProgramTarget #define NormalPbmplusMathProgramTarget(program) @@\ NormalProgramTarget(program,program.o,$(CURRENTDEPLIBS),$(CURRENTLIBS),-lm) #endif /* NormalPbmplusMathProgramTarget */ #ifndef InstallPbmplusPrograms #define InstallPbmplusPrograms(list,dest,flags) @@\ install:: list @@\ MakeDir($(DESTDIR)dest) @@\ @case '${MFLAGS}' in *[i]*) set +e;; esac; \ @@\ for i in list; do \ @@\ (set -x; $(RM) $(DESTDIR)dest/$$i; \ @@\ $(INSTALL) -c flags $$i $(DESTDIR)dest); \ @@\ done #endif /* InstallPbmplusPrograms */ #endif /* InstallMerged */ netpbm-8.2/README0100660000076400000000000006300607065334537012567 0ustar bryanhroot N E T P B M Release 8.2 Netpbm is a toolkit for conversion of images between a variety of different formats, as well as to allow a few basic image operations. The package is intended to be portable to many platforms. It has, at least at one time, been tested under various Unix-based systems, VMS and Amiga OS. There are also compiler directives in it for MS-DOS. The maintainer uses and builds it on a platform that consists mainly of GNU (which you may, unfortunately, know as "Linux"). There are over 180 separate tools in the package. The idea behind Netpbm is to define 3 very basic (and inefficient) portable graphics formats: PBM for black and white, PGM for grayscale, and PPM for color. These are collectively referred to as PNM. To convert from one common graphics format to another, you use a PNM format as an intermediate format. So if you want to convert among N image formats, you only need 2*N conversion filters, instead of the N^2 you would need if you wrote each conversion tool separately. In addition to the converters, the package includes some simple tools for manipulating the portable formats. For example, you can shrink an image or cut the top 10% off or make a mirror image. Among the 3 PNM formats, the Netpbm tools are are upwards compatible: A program to read PGM files will also read a PBM file, and a program to read PPM files reads all three. The image editing programs usually write the same type as they read. Whenever a program makes an exception and "promotes" a file to a higher format, it lets you know. The goal of Netpbm is to be a single source for all the primitive graphics utilities, especially converters, one might need. So if you know of some freely redistributable software in this vein which is not in the package yet, you should bring it to the attention of the Netpbm maintainer so it can be included in the next release. Netpbm replaces the widely spread pbmplus package (release: 10 Dec 91). A lot of improvements and additions have been made. After the latest release of pbmplus, a lot of additional filters began circulating on the net. The aim of Netpbm was to collect these and to turn them into a package. This work has been performed by a group of programmers all over the world. If *you* have some code to add, please contact the Netpbm maintainer. DISTRIBUTION ------------ You'll find the latest release of Netpbm at ftp.metalab.unc.edu, in the directory /pub/Linux/apps/graphics/convert. PREREQUISITES ------------- Don't sweat the prerequisites too much. In most cases, if you're missing something, the build of the programs that depend on it will bomb, but the rest of the Netpbm programs will build just fine. And you may not need the more demanding programs. If you have trouble getting, building, or installing the prerequisites, the Netpbm maintainer wants to know. Since he uses them himself, he can help you. And if there is a problem with a prerequisite package that its own maintainer cannot fix, it may be possible to ship a fix with Netpbm. Ordinarily, the Tiff library would be a prerequisite for building the Tiff tools, but we have included a complete version of the Tiff library in Netpbm. The main reason we did this is to make it easier for you to build, particularly in a way compatible with Netpbm. The automatic configuration tool that comes with the regular distribution of the library has bugs. The official source for the Tiff library is http://www.libtiff.org. To build ppmtojpeg or jpegtoppm, you need the JPEG/JFIF library from the Independent JPEG Group (IJG). You can get it at ftp://ftp.uu.net/graphics/jpeg. See http://www.ijg.org for more information. To build or use pnmtopng and pngtopnm, you need the zlib compression library and the png library. You can get zlib from ftp://quest.jpl.nasa.gov/pub/zlib or ftp://metalab.unc.edu/pub/Linux/libs. To build or use pnmtopng and pngtopnm, you need the png library (libpng). You can get it from ftp://ftp.au.netbsd.org/pub/NetBSD/packages/distfiles. If you want the tiff programs to be able to deal with JPEG-compressed tiff files, you need the jpeg library. You can get it at ftp://ftp.uu.net/graphics/jpeg. And see the web site http://www.ijg.org. If you don't have the jpeg library, you must specify so in the make files or you won't be able to build the tiff tools at all. INSTALLATION ------------ If you are building Netpbm on and for a typical GNU system (as virtually any system that uses the Linux kernel is), you can just do: make To build all the programs. Then make install to install them all. The only tricky part about installing is setting up the shared libraries that are part of Netpbm. 'make install' copies them into place, but that may not be enough. If you get mysterious "file not found" kinds of errors and are not an expert with shared libraries, see the section "SHARED LIBRARIES" below. Instead of 'make install', you may prefer to install manually -- just find all the executables in the pbm, pgm, ppm, and pnm subdirectories and put them in some directory in your search path. Find all the man pages, which have .N suffixes, and put them in your Man search path. And then find the 4 shared libraries (and optionally the Tiff shared library) and put them somewhere in your runtime library path. You can use make --dry-run install to see all of what has to be installed. The --keep-going option to Make is handy, because it causes Make to make anything it can, as opposed to quitting as soon as something goes wrong. With so many parts having so many requirements, it's not unusual for a few things to fail to build, but that doesn't affect everything else. You can work on the failed parts and repeat the make and it will attempt to build whatever it hasn't successfully built yet. INSTALLATION - NOT GNU ---------------------- If the standard make files don't work on your platform, then try using the following, which are the original installation instructions from pbmplus, which predates GNU. There are other sample make files in the distribution which may be of help. If you figure out how to install on other platforms, contact the Netpbm maintainer to have these instructions improved for the next person. Unpack the files. If you have the TIFF library (./libtiff) and are going to use it, copy the appropriate Makefile into place, read the comments in libtiff/README, and edit libtiff/tiffconf.h or the Makefile to reflect your compiler and options. Decide whether you want to use Imakefiles or Makefiles. If you want to use Makefiles: Edit the top-level Makefile, find each line with the string "CONFIGURE", and follow the directions for setting configuration options. Likewise edit pbmplus.h. If you are using gnu make, you have to edit *all* the Makefiles and remove all the imake stuff at the ends, otherwise gnu make will overwrite the Makefiles. Make. When you're happy that things compiled ok, make install. If you want to use Imakefiles: Edit Pbmplus.tmpl, find each line with the string "CONFIGURE", and follow the directions for setting configuration options. Likewise edit pbmplus.h. Save the original Makefiles, in case you later want to switch back to using them. The usual X11 sequence of xmkmf, make Makefiles, make depend, then make should work. If you have the TIFF libraries, the second step should be "make SUBDIRS='./pbm ./pgm ./ppm ./pnm' Makefiles". When you're happy that things compiled ok, make install and make install.man. After installing the manual pages, you may want to create the "whatis" file by doing a catman -w -M , or whatever the equivalent is on your system. SHARED LIBRARIES ---------------- There are over 180 programs in the Netpbm package and they do a lot of common things. In order to avoid the expense of copying the code for those common things into every program, Netpbm places it in 4 shared libraries: libpbm, libpgm, libppm, and libpnm. There is also libtiff shared library that comes with Netpbm. When you invoke a Netpbm program, your system notices that it needs these libraries and accesses them too. The tricky part of installing the shared (runtime) libraries is telling your system where to find them in the event that you invoke a Netpbm program. And that varies from one system to the next. Systems with a Linux kernel invariably use a program called ld-linux.so to locate shared libraries at runtime, with companion programs 'ldconfig' and 'ldd' and files /etc/ld.so.conf and /etc/ld.so.cache. On a Linux-based system, if you put the Netpbm shared libraries in a conventional spot (say, /lib) and reboot your system, chances are you will have no trouble running Netpbm programs. But if you want to fine tune things, read up on ld-linux.so and ldconfig and consider the /etc/ld.so.conf file and LD_LIBRARY_PATH environment variables. Use 'ldd' to see if you have a shared library issue. If it shows any shared library as "not found", you've got library trouble. One final note: New Netpbm executables often can run OK with old Netpbm shared libraries. This means if you don't correctly install the new libraries, you may run what you think is a new Netpbm program, but in actuality be accessing the old Netpbm library, and you may not even notice a problem right away. But eventually, you may find some things not working the way they should. Again, 'ldd' will give you peace of mind. HOW TO FIND THE RIGHT CONVERTER ------------------------------- Some people get confused by all the different names. If you want to convert a pbm file to a Sun raster file, is it pbmtorast, pgmtorast, ppmtorast, or pnmtorast? A useful tool for answering this question, if you have it configured, is man -k. You say "man -k " and it gives you all the one-line descriptions with that keyword in them. All the Netpbm man pages have nice useful one-line descriptions, that mention all the relevant keywords. Try it, you'll like it. Here is a brief directory of some of the Netpbm tools. Over the years, this list has not kept up with the growth of the package. A "pgmtoxxx" tool accepts PBM as well as PGM input and likewise a "ppmtoxxx" tool accepts PBM, PGM, and PPM. But a "xxxtopgm" tool always creates a PGM file and a "xxxtoppm" tool always creates a PPM file. A "pnmtoxxx" tool accepts all three input formats and behaves differently according to which it is. A "xxxtopnm" tool creates any of two or more of the formats, depending on input and command line options. CONVERTERS anytopnm convert any graphics format to Netpbm format ppmtojpeg convert portable pixmap to JPEG/JFIF format bmptoppm convert Windows or OS/2 Bitmap file to portable pixmap ppmtobmp convert portable pixmap to Windows or OS/2 Bitmap file giftopnm convert GIF to portable anymap ppmtogif convert portable pixmap to GIF pnmtopng convert portable anymap to Portable Network Graphics pngtopnm convert Portable Network Graphics to portable anymap. atktopbm convert Andrew Toolkit raster object to portable bitmap pbmtoatk convert portable bitmap to Andrew Toolkit raster object brushtopbm convert Xerox doodle brushes to portable bitmap cmuwmtopbm convert CMU window manager format to portable bitmap g3topbm convert Group 3 FAX to portable bitmap pbmtog3 convert portable bitmap to Group 3 FAX icontopbm convert Sun icon to portable bitmap pbmtoicon convert portable bitmap to Sun icon gemtopbm convert GEM .img format to portable bitmap macptopbm convert MacPaint to portable bitmap pbmtomacp convert portable bitmap to MacPaint mgrtopbm convert MGR format to portable bitmap pbmtomgr convert portable bitmap to MGR format pi3topbm convert Atari Degas .pi3 to portable bitmap pbmtopi3 convert portable bitmap to Atari Degas .pi3 xbmtopbm convert X10 or X11 bitmap to portable bitmap pbmtoxbm convert portable bitmap to X11 bitmap pbmtox10bm convert portable bitmap to X10 bitmap ybmtopbm convert Bennet Yee "face" file into portable bitmap pbmtoybm convert portable bitmap into Bennet Yee "face" file pbmto10x convert portable bitmap to Gemini 10x printer graphics pbmtoascii convert portable bitmap to ASCII graphic form asciitopgm convert ASCII character graphics to portable graymap pbmtobbnbg convert portable bitmap to BBN BitGraph graphics pbmtocmuwm convert portable bitmap to CMU window manager format pbmtoepson convert portable bitmap to Epson printer graphics pbmtogem convert portable bitmap into GEM .img file pbmtogo convert portable bitmap to GraphOn graphics pbmtolj convert portable bitmap to HP LaserJet graphics pbmtoplot convert portable bitmap into Unix plot(5) file pbmtoptx convert portable bitmap to Printronix graphics pbmtozinc convert portable bitmap to Zinc Interface Library icon fitstopnm convert FITS format to portable anymap pnmtofits convert portable anymap to FITS format fstopgm convert Usenix FaceSaver(tm) format to portable graymap pgmtofs convert portable graymap to Usenix FaceSaver(tm) format hipstopgm convert HIPS format to portable graymap lispmtopgm convert a Lisp Machine bitmap file into pgm format pgmtolispm convert a portable graymap into Lisp Machine format psidtopgm convert PostScript "image" data to portable graymap rawtopgm convert raw grayscale bytes to portable graymap pgmtopbm convert portable graymap to portable bitmap pbmmask create a mask bitmap from a regular bitmap gouldtoppm convert Gould scanner file to portable pixmap ilbmtoppm convert IFF ILBM to portable pixmap ppmtoilbm convert portable pixmap to IFF ILBM imgtoppm convert Img-whatnot to portable pixmap mtvtoppm convert MTV ray-tracer output to portable pixmap pcxtoppm convert PC Paintbrush format to portable pixmap pgmtoppm colorize a portable graymap into a portable pixmap pi1toppm convert Atari Degas .pi1 to portable pixmap ppmtopi1 convert portable pixmap to Atari Degas .pi1 picttoppm convert Macintosh PICT to portable pixmap ppmtopict convert portable pixmap to Macintosh PICT pjtoppm convert HP PaintJet file to portable pixmap ppmtopj convert portable pixmap to HP PaintJet file qrttoppm convert QRT ray-tracer output to portable pixmap rawtoppm convert raw RGB bytes to portable pixmap rgb3toppm combine three portable graymaps into one portable pixmap ppmtorgb3 separate a portable pixmap into three portable graymaps sldtoppm convert an AutoCAD slide file into a portable pixmap spctoppm convert Atari compressed Spectrum to portable pixmap sputoppm convert Atari uncompressed Spectrum to portable pixmap tgatoppm convert TrueVision Targa file to portable pixmap ppmtotga convert portable pixmap to TrueVision Targa file ximtoppm convert Xim to portable pixmap xpmtoppm convert XPM format to portable pixmap ppmtoxpm convert portable pixmap to XPM format yuvtoppm convert Abekas YUV format to portable pixmap ppmtoyuv convert portable pixmap to Abekas YUV format ppmtoyuvsplit convert portable pixmap to 3 subsampled raw YUV files yuvsplittoppm merge 3 subsampled raw YUV files to one portable pixmap ppmtoacad convert portable pixmap to AutoCAD database or slide ppmtoicr convert portable pixmap to NCSA ICR graphics ppmtopcx convert portable pixmap to PC Paintbrush format ppmtopgm convert portable pixmap to portable graymap ppmtopuzz convert portable pixmap to X11 "puzzle" file ppmtosixel convert portable pixmap to DEC sixel format ppmtouil convert portable pixmap to Motif UIL icon file rasttopnm convert Sun raster file to portable anymap pnmtorast convert portable anymap to Sun raster file tifftopnm convert TIFF file to portable anymap pnmtotiff convert portable anymap to TIFF RGB file pnmtotiffcmyk convert portable anymap to TIFF CMYK file xwdtopnm convert X10 or X11 window dump to portable anymap pnmtoxwd convert portable anymap to X11 window dump pnmtops convert portable anymap to Postscript pstopnm convert Postscript to portable anymap pnmtoplainpnm convert a regular portable anymap into plain pnm format pbmtoepsi convert a PBM image to encapsulated Postscript preview bitmap pbmtopgm convert PBM file to PGM by averaging areas IMAGE EDITORS pbmlife apply Conway's rules of Life to a portable bitmap image pbmmake create a blank portable bitmap image of a specified size ppmmake create a pixmap of a specified size and color ppmpat create a pretty pixmap pgmnoise create a portable graymap of white noise pbmreduce reduce a portable bitmap N times, using Floyd-Steinberg pbmtext render text into a portable bitmap image pbmupc create a Universal Product Code portable bitmap image pgmnorm normalize contrast in a portable graymap image ppmnorm normalize contrast in a portable pixmap image pbmpscale englarge a portable bitmap image with edge smoothing pnmscale scale a portable anymap image ppmdither ordered dither for color images ppmquant quantize colors in an image down to a specified number ppmquantall quantize colors down to a specified number on many files ppmrelief run a Laplacian Relief filter on a portable pixmap pnmarith perform arithmetic on two portable anymaps pnmcat concatenate portable anymaps pnmconvol general MxN convolution on a portable anymap pnmcrop crop all like-colored borders off a portable anymap pnmcut select a rectangular region from a portable anymap pnmdepth change the maxval in a portable anymap pnmenlarge enlarge a portable anymap N times pnmflip perform one or more flip operations on a portable anymap pnminvert invert a portable anymap pnmgamma perform gamma correction on a portable anymap pnmmargin script to add a margin to a portable anymap pnmpaste paste a rectangle into a portable anymap pnmrotate rotate a portable anymap pnmshear shear a portable anymap pnmsmooth smooth a portable anymap image pnmtile replicate a portable anymap into a specified size pbmclean remove lone pixels (snow) from a portable bitmap image pnmalias antialias a portable anymap image pnmcomp create composite of two portable anymap images pnmpad add borders to a portable anymap ppmchange change all of one color to another in portable pixmap image ppmdim dim a portable pixmap image ppmshift shift lines of PPM image left or right a random amount ppmspread move pixels of PPM image a random amount IMAGE ANALYZERS pgmedge edge-detect a portable graymap pgmenhance edge-enhance a portable graymap pgmramp generate a grayscale ramp pgmtexture calculate textural features on a portable graymap pgmhist print a histogram of the values in a portable graymap ppmhist print a histogram of a portable pixmap pnmfile describe a portable anymap MISCELLANEOUS pgmbentley Bentleyize a portable graymap pgmcrater create cratered terrain by fractal forgery pgmoil turn a portable graymap into an oil painting ppmforge fractal forgeries of clouds, planets, and starry skies pnmindex build a visual index of a bunch of anymaps pgmkernel generate a convolution kernel UNCATALOGUED AS YET bioradtopgm hpcdtoppm pbmto4425 pbmtoln03 pbmtolps pbmtopk pktopbm pnmhisteq pnmhistmap pnmnlfilt pnmtoddif pnmtosgi pnmtosir ppm3d ppmbrighten ppmdist ppmflash ppmmix ppmntsc ppmqvga ppmtomap ppmtomitsu ppmtopjxl sgitopnm sirtopnm spottopgm xvminitoppm zeisstopnm SUPPORT ------- The maintainer of Netpbm, since September 1999, is Bryan Henderson: bryanh@giraffe-data.com. Bryan actively maintains the package and wants to know about any problems people have with Netpbm or suggestions for improvement. OTHER GRAPHICS SOFTWARE ----------------------- Netpbm contains primitive building blocks. It certainly is not a complete graphics library. The first thing you will need to make use of any of these tools is a viewer. Zgv is a good viewer to use on a GNU/Linux system with the SVGALIB graphics display driver library. You can find zgv at ftp://metalab.unc.edu/pub/Linux/apps/graphics/viewers. Zgv even has a feature in it wherein you can visually crop an image and write an output file of the cropped image using pnmcut. See the -s option to zgv. HISTORY ------- See the file HISTORY. COPYRIGHTS ---------- All the software in this package, regardless of who wrote and contributed it, has a copyright similar to this one: Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. This software is provided "as is" without express or implied warranty. Many people get confused by this legalese, especially the part about "without fee". Does this mean you can't charge for any product that uses Netpbm? No. All it means is that you don't have to pay me. You can do what you want with this software. Build it into your package, steal code from it, whatever. Just be sure to let people know where it came from. Another restriction that some of the software has is that in order to have permission to copy it (which includes writing anything derived from it), you must distribute source code for your copy or derivation and propagate the same restriction to people who would copy your derivation. In other words, the price the author wants for the use of his proprietary work is your contribution to the free software cause. CONTENTS -------- Files in top directory: README this README.JPEG From the JPEG library, legally required to be here. HISTORY list of changes between the various versions of PBM FORMATS list of the formats supported Makefile guess Imakefile for X11-type installations Imakefile.tiff for X11-type installations Pbmplus.tmpl for X11-type installations pbmplus.h header file for PBM, PGM, PPM, and PNM compat.csh csh script for compatibility with old versions compat.ksh ksh script for compatibility with old versions magic additions for /etc/magic to recognize some image formats testimg.ppm This is a sample image file for testing the programs. Files in pbm directory: Makefile guess Imakefile for X11-type installations Source code for tools which convert to and from PBM format. libpbm[1-5].c a few utility routines pbmmerge.c merge wrapper routine pbm.h header file for libpbm pbmfont.h header file for font routines in libpbm libpbm.h internal header file for libpbm g3.h definitions for Group 3 FAX macp.h definitions for MacPaint files bitreverse.h useful include file *.1 manual entries for all of the tools pbm.5 manual entry for the pbm format libpbm.3 manual entry for the pbm library Files in pgm directory: Makefile guess Imakefile for X11-type installations libpgm[1-3].c a few utility routines pgmmerge.c merge wrapper routine pgm.h header file for libpgm libpgm.h internal header file for libpgm dithers.h useful include file *.1 manual entries for all of the tools pgm.5 manual entry for the pgm format libpgm.3 manual entry for the pgm library Files in ppm directory: Makefile guess Imakefile for X11-type installations libppm[1-5].c a few utility routines ppmmerge.c merge wrapper routine ppm.h header file for libppm ppmcmap.h header file for colormap routines in libppm ppmdraw.h header file for simple drawing routines in libppm libppm.h internal header file for libppm autocad.h definitions for AutoCAD files tga.h definitions for TrueVision Targa files xim.h definitions for Xim files *.1 manual entries for all of the tools ppm.5 manual entry for the ppm format libppm.3 manual entry for the ppm library Files in pnm directory: Makefile guess Imakefile for X11-type installations libpnm[1-4].c a few utility routines pnmmerge.c merge wrapper routine pnm.h header file for libpnm rast.h definitions for Sun raster files x10wd.h definitions for X10 window dumps x11wd.h definitions for X11 window dumps *.1 manual entries for all of the tools pnm.5 manual entry for the pnm format libpnm.3 manual entry for the pnm library netpbm-8.2/README.CONFOCAL0100660000076400000000000000465305453764446013762 0ustar bryanhrootAdditions to the PbmPlus package. This enhanced version of the PbmPlus package supports reading of files from three different confocal scanners, the Molecular Dynamics (Sarastro), the Biorad and the Zeiss. The package can convert from any of these images to the pbm format, from which it can produce gif, tiff, x11 dumps, mac paint, etc. In order to convert from a confocal image format, use the following commands: * Molecular Dynamics (Sarastro) and Leica: rawtopgm -tb [file] > outfile.pgm For more information, give the command "man rawtopgm" * Biorad bioradtopgm [-image#] [file] > outfile.pgm For more information, give the command "man bioradtopgm" * Zeiss (old format) zeisstopnm [-pgm|-ppm] [file] > outfile.pnm For more information, give the command "man zeisstopnm" * Zeiss (new format) tifftopnm [file] > outfile.pnm I have tested the programs on one Zeiss file (old format) and on one Biorad file. There probably remain some bugs to be fixed. Please report them to me when you encounter them (email:oliver@fysik4.kth.se). I have compiled and installed the PbmPlus package on the following machines: * Silicon graphics (Personal Iris) with gcc 2.4.0 * Sun386i with gcc 2.4.0 BUGS The libtiff part can be tricky to compile. On an sgi I managed to use gcc. On a sun386i, I had to compile tif_dir.c, tif_error.c and tif_warning.c with cc instead. The rest of the files could be compiled with gcc. On the sun386i, the pgmtexture.c file would not compile with gcc -O. It worked fine without the optimization flag. Probably a bug in gcc. From the README file: COPYRIGHTS All the software in this package, whether by me or by a contributer, has a copyright similar to this one: Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. This software is provided "as is" without express or implied warranty. Many people get confused by this legalese, especially the part about "without fee". Does this mean you can't charge for any product that uses PBMPLUS? No. All it means is that you don't have to pay me. You can do what you want with this software. Build it into your package, steal code from it, whatever. Just be sure to let people know where it came from. netpbm-8.2/README.VMS0100750000076400000000000001540005533364724013225 0ustar bryanhroot 25-FEB-1994 Hi VAX/VMS and future PBMplus users!!! This version of Jef Poskanzer's PBMplus package is ready-made to support the DEC VAX/VMS C environment. In an attempt to make it run like the Unix environment, the programs have been modified to look like they use the "piping" and "redirection" features of Unix and MSDOS. In this way, the documentation and other people's comments (i.e., USENET alt.graphics.pixutils discussions, etc.) will be the same for all platforms. This VMS implementation borrows heavily from the previous PBMplus/VMS release by Rick Dyson for 10dec91 which in turn builds on the work Terry Poot (tp@mccall.com) did for the 05feb91 general release of PBMplus. Many thanks and credits go his direction. The "piping/redirection" is attributed to Mark Pizzolato (mark@infopiz.uucp). The creation of the shareable library is due to work done by Dave Jones (JONESD@kcgl1.eng.ohio-state.edu). Well, since you are reading this, I guess you have the PBMplus kit and have broken it out into it's respective directories. At this point you just have to start the build operation. In this release of the PBMplus package the process is much easier than in the past. There is no patching of the source code necessary and so there is no extra "patch-build kit". This contains everything you need to build the PBMplus package. There is only one step to the preparation process and that is to copy all the files from the [.VMS] sub-directory up one level into the root [PBMplus] directory. "MAKEFILE.MMS" ------------- There are two methods of building the executables. The first (and prefered) method uses DECs "makefile" utility, MMS, which uses the "MAKEFILE.MMS" files. If you don't have MMS, skip to the section labeled "MAKE_PBMPLUS.COM" below. If you are still with me, just type "MMS /Description = Makefile.MMS" and follow the directions outlined on the screen. Your most probable sequence will be the something like the following: $ MMS /Description = Makefile.MMS ALL $ MMS /Description = Makefile.MMS INSTALL ! creates & loads [.Exe] $ MMS /Description = Makefile.MMS HELP ! make PBMPLUS.HLB $ MMS /Description = Makefile.MMS MANUAL ! will need LaTeX and tr2TeX... $ MMS /Description = Makefile.MMS INSTALLMANUAL ! creates & loads [.TeX] $ MMS /Description = Makefile.MMS CLEAN ! clean up all recoverable files The available choices will be displayed if you don't say anything, i.e. $ MMS /Description = Makefile.MMS "MAKE_PBMPLUS.COM" ------------------ The other method of building the package is to execute the "MAKE_PBMPLUS.COM" command procedure. This was mostly created by the "MMS BUILD_PROC" command. It is not as flexible as MMS, but should get the job done. Look through the procedure and edit it as you see fit. It builds and installs just about everything, so it might be in your best interest to look through it and use your veto powers to comment out the unneeded (or unavailable) parts. Be sure to look and check what you have before executing the procedure. "SETUP.COM" ----------- I have provided two setup files with this distribution to facilitate the day-to-day use of PBMplus. All you need to do is execute the SETUP.COM command procedure and it will make all the logical name and foreign symbol definitions. You should look through SETUP.COM and read the comments about the rooted logical names used. After all that, look through the TeX documentation or the on-line help files to get an idea of how to start using PBMplus. NOTE: An error in MMS will occur if you have used SETUP.COM before using MMS. A logical name conflict or something. Either logout and login to clear things out or Deassign PBMplus_Root and PBMplus_Dir before using MMS. Manifest -------- The following files are included with this VMS port of PBMplus. The bare essential ones needed to complete the build are marked with an astreisk (*): [.VMS]MAKEFILE.MMS -- VMS MMS description file (i.e., "makefile") for all of PBMplus *[.VMS]MAKE_PBMPLUS.COM -- VMS command procedure produced by MMS to build the PBMplus package for users without MMS *[.VMS]MAKE_PBMPLUSSHR.COM -- VMS command procedure to build Shareable link library of the four main PBMplus object libraries; LIBPBM, LIBPGM, LIBPPM, & LIBPNM [.VMS]SETUP.COM -- An initialization/definition command proc for "everyday use" of PBMplus once it's built [.VMS]ADD_LIST.COM -- Generic command procedure to add another library to any VMS librarian list, (i.e., Hlp$Library_nn or Lnk$Library_nn) [.VMS]PBMPLUS.HLP -- VMS Help library file for all of PBMplus [.PBM]MAKEFILE.MMS -- VMS MMS description file for PBM routines [.PGM]MAKEFILE.MMS -- VMS MMS description file for PGM routines [.PPM]MAKEFILE.MMS -- VMS MMS description file for PPM routines [.PNM]MAKEFILE.MMS -- VMS MMS description file for PNM routines [.LIBTIFF]MAKEFILE.MMS -- VMS MMS description file for LIBTIFF routines When it's all over and done, the PBMplus directory tree should resemble the following: PBMPLUS ---+ EXE <-- the binaries | + LIBTIFF <-- TIFF library | + PBM <-- Portable BitMaps | + PGM <-- Portable Grayscale Maps | + PNM <-- Portable aNy Maps | + PPM <-- Portable Picture Maps | + VMS <-- VMS specific files Rick Dyson -- Richard L. Dyson INTERNET: Dyson@IowaSP.Physics.UIowa.EDU _ _ _____ Senior Programmer Analyst O: 319/335--1879 | | | | |_ _| Department of Physics & Astronomy H: 319/338--6117 | | | | of | | Van Allen Hall NSI/DECnet: IOWASP::DYSON | \_/ | _| |_ University of Iowa or : 7231::DYSON \___/ |_____| Iowa City, IA 52242-1479 netpbm-8.2/SMakefile0100640000076400000000000002004305521553166013456 0ustar bryanhroot# Makefile for pbmplus tools. # # Copyright (C) 1989, 1991 by Jef Poskanzer. # Modified by Robert A. Knop Jr. (rknop@cco.caltech.edu) 940126 for # Amiga SAS/C 6.0 or greater (tested with 6.50) # Merge is not currently supported by this makefile # LibTIFF is not currently supported by this makefile (perhaps soon...) # RKNOP has also created "SMakefile"s in each of {pbm/ pgm/ ppm/ pnm/} # which were similarly based on the Unix Makefile# # The shell utility "foreach" (should have been included in the archive with) # this SMakefile) is necessary for the SMakefiles to work. # Feel free to experiment with SCOPTIONS, although these have been tweaked # at great length to get netpbm to compile. It is probably wise to have # the SCOPTIONS files in the four subdirectories identical to the one # in the top netpbm source directory. # All changes pertinent to SAS/C 6.x are labeled by the word "RKNOP" # # Permission to use, copy, modify, and distribute this software and its # documentation for any purpose and without fee is hereby granted, provided # that the above copyright notice appear in all copies and that both that # copyright notice and this permission notice appear in supporting # documentation. This software is provided "as is" without express or # implied warranty. # CONFIGURE: gcc makes things go faster on some machines, but not everyone # has it. Warning: do not use gcc's -finline-functions or -fstrength-reduce # flags, they can produce incorrect code. (This is with gcc versions 1.35, # 1.36, and 1.37, later versions may fix these bugs.) Also, on some systems # gcc can't compile pnmconvol - dunno why. And on some systems you can't # use the -ansi flag, it gives compilation errors in . # For the Amiga, the makefiles will die severely if you don't use SAS/C 6.x #CC = cc #CC = gcc CC = sc #CC = gcc -fcombine-regs -fpcc-struct-return #CC = gcc -ansi -pedantic -fcombine-regs -fpcc-struct-return # CONFIGURE: cc flags go here. # On some systems, e.g a sun386i, there is no strstr function. If this # is the case on your system, set the -DNEED_STRSTR flag. #CFLAGS = -O #CFLAGS = -O -DNEED_STRSTR #CFLAGS = -g #CFLAGS = -g -O CFLAGS = MFLAGS = # CONFIGURE: ld flags go here. Eunice users may want to use -noshare so that # the binaries can run standalone. LDFLAGS #LDFLAGS = -s #LDFLAGS = #LDFLAGS = -noshare # CONFIGURE: PBMPLUS's support for TIFF files depends on the library from # Sam Leffler's TIFF Software package - see the OTHER.SYSTEMS file for a # full description and access information. To configure PBMPLUS to use the # library: first, if necessary, fetch the TIFF Software, unpack it in a # scratch directory somewhere, and move the libtiff subdirectory right here # into the PBMPLUS top-level directory. Configure and "make" in the # libtiff directory. Yes, you do have to do the TIFF make by hand, the # general PBMPLUS make will *not* make libtiff. Finally, uncomment the # following five definitions. # # Libtiff is pretty good about portability, but there are some machines # it has problems on. If you run into problems, you may wish to contact # Sam directly, at the address listed in the OTHER.SYSTEMS file. # # By the way, you must have at least version 2.4 of libtiff. Earlier # versions will not work. # # RKNOP: The SAS/C version does not yet have a converted libtiff SMakefile TIFFDEF = TIFFINC = TIFFLIB = TIFFBINARIES = TIFFOBJECTS = #TIFFDEF = -DLIBTIFF #TIFFINC = -I../libtiff #TIFFLIB = ../libtiff/libtiff.a #TIFFBINARIES = tifftopnm pnmtotiff #TIFFOBJECTS = tifftopnm.o pnmtotiff.o # CONFIGURE: Define the directory that you want the binaries copied to. # If you need scripts and binaries to be in different directories, you # can set that up too. #INSTALLBINARIES = sys:netpbm INSTALLBINARIES = Laertes:CCode/netpbm-exec INSTALLSCRIPTS = $(INSTALLBINARIES) # CONFIGURE: Define the directories that you want the manual sources copied to, # plus the suffix you want them to have. INSTALLMANUALS1 = sys:netpbm-man/man1 SUFFIXMANUALS1 = 1 INSTALLMANUALS3 = sys:netpbm-man/man3 SUFFIXMANUALS3 = 3 INSTALLMANUALS5 = sys:netpbm-man/man5 SUFFIXMANUALS5 = 5 # CONFIGURE: Normally the man pages are installed using "cp". By changing # this define you can use something else, for example a script that calls # compress or pack. The ../mantocat is used on systems which use man pages # in the "cat" format. MANCP = copy #MANCP = cp #MANCP = ../mantocat # CONFIGURE: Normally the Makefiles build and install separate binaries for # each program. However, on some systems (especially those without shared # libraries) this can mean a lot of space. In this case you might try # building a "merge" instead. The idea here is to link all the binaries # together into one huge executable, with a tiny dispatch program as the # main. Then the merged binary is installed with file-system links for # each program it includes. The dispatch routine can tell which program # to run by looking at argv[0]. On a Sun3 under SunOS 3.5 the space for # executables went from 2.9 meg to .36 meg. # # Note that if you make a "merge", the executables don't get created # until you do the install. # RKNOP: Merge is not supported for Amiga SAS/C all: binaries install: install.bin install.man #all: merge #install: install.merge install.man # End of configurable definitions. SHELL = /bin/sh #MAKE = make MAKE = smake SUBDIRS = pbm pgm ppm pnm binaries: execute stamp-date.amiga execute < <(T:main_smake.tmp) foreach im in $(SUBDIRS) echo $${im} cd $${im} $(MAKE) $(MFLAGS) CC=$(CC) CFLAGS=$(CFLAGS) TIFFDEF=$(TIFFDEF) TIFFINC=$(TIFFINC) TIFFLIB=$(TIFFLIB) TIFFBINARIES=$(TIFFBINARIES) TIFFOBJECTS=$(TIFFOBJECTS) LDFLAGS=$(LDFLAGS) binaries end < # RKNOP 940126 # "smake nostamp" will do the same as "smake" or "smake binaries", only # stamp-date.amiga will NOT be run. This is convenient if you are # experimenting and a build tends to die halfway through... the samkefile can # continue to use the old compile.h (which normally stamp-date creates) and # whatever objects files previous passes at the compilation have left behind nostamp: execute < <(T:main_smake.tmp) foreach im in $(SUBDIRS) echo $${im} cd $${im} $(MAKE) $(MFLAGS) CC=$(CC) CFLAGS=$(CFLAGS) TIFFDEF=$(TIFFDEF) TIFFINC=$(TIFFINC) TIFFLIB=$(TIFFLIB) TIFFBINARIES=$(TIFFBINARIES) TIFFOBJECTS=$(TIFFOBJECTS) LDFLAGS=$(LDFLAGS) binaries end < #merge: # ./stamp-date # for i in $(SUBDIRS) ; do \ # ( echo $$i ; cd $$i ; $(MAKE) $(MFLAGS) 'CC=$(CC)' 'CFLAGS=$(CFLAGS)' 'TIFFDEF=$(TIFFDEF)' 'TIFFINC=$(TIFFINC)' 'TIFFLIB=$(TIFFLIB)' 'TIFFBINARIES=$(TIFFBINARIES)' 'TIFFOBJECTS=$(TIFFOBJECTS)' 'LDFLAGS=$(LDFLAGS)' merge ); \ # done install.bin: -makedir $(INSTALLBINARIES) execute < <(T:main_smake.tmp) foreach im in $(SUBDIRS) echo $${im} cd $${im} $(MAKE) $(MFLAGS) CC=$(CC) CFLAGS=$(CFLAGS) TIFFDEF=$(TIFFDEF) TIFFINC=$(TIFFINC) TIFFLIB=$(TIFFLIB) TIFFBINARIES=$(TIFFBINARIES) TIFFOBJECTS=$(TIFFOBJECTS) LDFLAGS=$(LDFLAGS) INSTALLBINARIES=$(INSTALLBINARIES) INSTALLSCRIPTS=$(INSTALLSCRIPTS) install.bin end < #install.merge: # -mkdir $(INSTALLBINARIES) # for i in $(SUBDIRS) ; do \ # ( echo $$i ; cd $$i ; $(MAKE) $(MFLAGS) 'CC=$(CC)' 'CFLAGS=$(CFLAGS)' 'TIFFDEF=$(TIFFDEF)' 'TIFFINC=$(TIFFINC)' 'TIFFLIB=$(TIFFLIB)' 'TIFFBINARIES=$(TIFFBINARIES)' 'TIFFOBJECTS=$(TIFFOBJECTS)' 'LDFLAGS=$(LDFLAGS)' 'INSTALLBINARIES=$(INSTALLBINARIES)' 'INSTALLSCRIPTS=$(INSTALLSCRIPTS)' install.merge ); \ # done install.man: execute < <(T:main_smake.tmp) foreach im in $(SUBDIRS) echo $${im} cd $${im} $(MAKE) $(MFLAGS) TIFFBINARIES=$(TIFFBINARIES) INSTALLMANUALS1=$(INSTALLMANUALS1) SUFFIXMANUALS1=$(SUFFIXMANUALS1) INSTALLMANUALS3=$(INSTALLMANUALS3) SUFFIXMANUALS3=$(SUFFIXMANUALS3) INSTALLMANUALS5=$(INSTALLMANUALS5) SUFFIXMANUALS5=$(SUFFIXMANUALS5) MANCP=$(MANCP) install.man end < clean: -delete *.shar *.shar? art.* compile.h #libtiff removed from the foreach below for the time being execute < <(T:main_smake.tmp) foreach im in $(SUBDIRS) echo $${im} cd $${im} $(MAKE) $(MFLAGS) clean end < netpbm-8.2/amiga/0040770000076400000000000000000006765574353012772 5ustar bryanhrootnetpbm-8.2/amiga/README.SASC0100640000076400000000000000407705521553612014366 0ustar bryanhrootSAS/C SMakefiles for SAS/C 6.0 and greater have been created by Robert A. Knop Jr. (rknop@cco.caltech.edu). These Makefiles have been tested with SAS/C 6.51. They are based on the 7dec1993 release of netpbm. See also README.AMIGA for DICE, Amiga binary, and Amiga general information from Ingo Wilken. The following files are specific to SAS/C SMakefiles: SMakefile - Top level makefile, runs SMakefiles in pbm, pgm, ppm, pnm SCOPTIONS - SAS/C options file foreach_amiga.lha - Amiga Shell utility needed in the SMakefiles pbm/SMakefile - make file for pbm, run by top level SMAkefile pbm/SCOPTIONS - should be same as top level SCOPTIONS pgm/SMakefile - make file for pgm, run by top level SMAkefile pgm/SCOPTIONS - should be same as top level SCOPTIONS ppm/SMakefile - make file for ppm, run by top level SMAkefile ppm/SCOPTIONS - should be same as top level SCOPTIONS pnm/SMakefile - make file for pnm, run by top level SMAkefile pnm/SCOPTIONS - should be same as top level SCOPTIONS The shell script stamp-date.amiga by Ingo Wilken is used by the SAS/C Amiga SMakefile. To build netpbm with SAS/C: (1) Decompact the netpbm source archive (presumably you've already done this if you are reading this file). The top level directory should have, among others, subdirectories "pbm", "pgm", "ppm", and "pnm". CD to this top level directory. (2) Install foreach somewhere in your path, e.g. c: (3) In the top level directory, type "smake". This will build all of the binaries. (4) Edit the top-level SMakefile, changing the definition of the variables INSTALLBINARIES, INSTALLMANUALS1, INSTALLMANUALS3, and INSTALLMANUALS5 to reflect where on your system you want the executables and man pages to go. (5) In the top level directory, type "smake install". This will copy the executables to $(INSTALLBINARIES) and the man pages to $(INSTALLMANUALS?). (6) In the top level directory, type "smake clean". This will delete the copies of the executables from the source tree, the .o object files, and other chaff. -R. Knop 93/01/26netpbm-8.2/amiga/foreach.lha0100640000076400000000000001223005521554202015035 0ustar bryanhrootD-lh5- 0% Foreach_sѴܣ8v(nz>,Eq:1\en[99=@MTʩ |mVUU|UPh]0U "FQvJm\l+l}d6ryvᬍ"wɿiǻA69{=T-xA^$v9J#MfslƱZ W=J<A65nR4rFFH> ,XIm`@15N+̧"JFAz ]ɤtBCw;_Q'LtAz`65WX]r?RS<ܖq Ϗ;j{(>ˬINia6uU `@Na~ lė-V |K ? a-(ޤ2SXyP.k[t@6ޚ.Ãtˌ=XVw)֧D*tY4z?UA0k~{ φ%_Q];ɰ38A D56ؚgaTS]pO&r^`Jx7JY%[4tg9WՕo=?Wlhv^zgTbukB;9 j-}BֈG4Ɨ;\|5M}k:&%Q6~YDcw6?oco1Ě[-{3LhbDӛypzi'Q'Ԇǹ!b&Ǻ_b%Ca14ۚ?UWuL6=:u%6c#]?/y_ylUǜq Bwjq>ZaU+oR w]ٵ1I>Ɛk w%8YeA1HU e[ߜp"Z_~ ܴ/Sˤ ,mA$4N_$rEbAda-fTaҳo9 h)r hrx$'̝h%Z=O:ݺʺ A>',p{U6E7ȫqSg<ϝk?~|tna\4bu!pŝlPO&4۲DLPvKkD޺@Ѝ=;V |qr]?C^2FqҾpn5iia`5 cx$;/|МR`{=#z&fHvCucxq|3xnNRce{;dnciݲ[ЇR2Ÿù1HFm9D[R~QL[7 Eum<DE/I\}dOos7^f/tz$s[I>kIľmy45D['Ac |/0)B0~yDv4Md T_FE"S4]GN-z)Q5OhJ'gn'ߡ>&룇0׋?vdg1Wku"di֧7!>n|ԁǼ8rRS3o;4x\C=[1n!2}lV ΓL1M#n[1}@9a]VS:4֦}ab`0?NmQxVPzd\pנۍ4MF+LVk~tW f4aЫb-i7n, r)(NN&^圴%))'̑M N4jhg08Éfmh-ёLOfltJtG ۘ4=.qkf/;r9𓑦ΏE1WʵU+Έymls>|*zIdWKl89wAs8U,l9絇0Xk %u!OkS$֘:?ӈ7V(!nIP:4l--t W-w؛LCq ^_*}b9F7l|?)y3+G߸iD!;}&dtff;^iݻ1]NdYt45> tIN'ޮ23)px!hHwM0.(ט,Q,C:xqƅԀJY$npsMH{Sw kKL .]1ȸ Rh)}_G"MAA`AN:%0-TS7v.AP}9ϰib[lGz{}cVk;fH`m==a:Cyb;!P-lh5- Y Foreach.docsqܷ`FQ='0Gjl4t tE$kJO5|n'Me] xx{@ζ֛]nĺ3:R;Jt׎P1ͶԧScs%JUQJӕ`=SS X's&hЦ츑d] ȼ/`cVS*ZkzM|1:uQSju-fI& uKPYe[KT JBhS;I绉.Lj=ka/)0()x&B OsE5[hYe$&qef`dYj]+P\Jdjj}Eԭvӝu,y~p>71z܎Ӯf~ԛОV7t{i%!nwތWyB[OM^//8m8#ÊL8,Q4L#&a :QMÉ0i4z+IN6ʬnqz6moNC%^⎜cj1O]r߮$"76"qʤym.o-`M֐Jӥe U1ڎ8J3 UQWUdF jTyFFV=cVH|*TF4b($T$G"Q`=zҀn{n἟,nmX##xg/=v-Z`<<_&xHl5%#.ٗjSф㠨=q2\T/Bc'0`@7LNmzS(ꪀ.Dx}-ML&5$4LNtBBEҶ" _$ƩAHOLhE *P%n,iD/qd)W$:txdF"yAEI3+Xţؔ{bp2Bxhm,B$ON;'a1c@`tIw)e*|;kU Ac}x@R":A$x; DdEP)p$G1Y.-FZء xcFԯv*+'0 @_adۆ>y}i&`3Y ś[Aҭ } Ҹ^ZG FrbJf顔 k8@da?p.(WsDeQ_]YSNu{u$G oIaoz'nR:VKa7@tdU,S$q,k98!(T7JͺU"=T iދ:wW\a[3K$Ti{D9j$Ab㤕G@T;fJlh̦72g(wx:A03{]d6`7iMydH7'DfC:D&P4#ӻS(|Q&e+'jόhIDUmQEagW5!'7@ G åugV̵$.]9u/_Pq[JG8[f [+EN -ᆞ,d=SU379#½s^8a yVk+,s.h:o <՘,|:OI#P NƧ8# aHRv5jqoA(p^A>O?<;E؟gN xpO6پ )wDŽ\W F qO>eY1YxAbmnetpbm-8.2/amiga/NETPBM.INTRO0100640000076400000000000002530005534460737014561 0ustar bryanhroot NETPBM Image conversion and processing package Amiga information Binaries -------- Binaries are available at ftp.informatik.uni-oldenburg.de [134.106.1.9] in /pub/netpbm/amiga, or on all Aminet sites in /pub/aminet/gfx/pbm. The full distribution consists of these archives: texts.lha REQ textfiles, miscellaneous stuff manuals.lha REQ formatted Unix manuals mergedbin.lha REQ* merged binaries pbmbin.lha REQ* PBM binaries, for B&W images pgmbin.lha REQ* PGM binaries, for greyscale images ppmbin1.lha REQ* PPM binaries #1, for color images ppmbin2.lha REQ* PPM binaries #2, for color images pnmbin.lha REQ* PNM binaries, tools and special converters scripts.lha OPT Unix shell scripts source1.lha DEV source: tools and main libraries source2.lha DEV source: TIFF library, Unix nroff manuals, VMS stuff dicelibs.lha DEV compiled link libraries, for DICE REQ = required, OPT = optional, DEV = only useful for programmers *: You need either all the p?mbin archives, or just the mergedbin archive. See the section "Merged binaries vs Separate binaries" for an explanation. What is NETPBM? --------------- NETPBM is a revised version of the PBMplus package, containing corrections and enhancements to the 10dec91 version of PBMplus. It is not "official" in the sense of being released by the original author, but the idea of a net supported version has been approved by him. NETPBM is a collection of tools which do the following: 1. Import - read images in popular formats and convert to one of the internal PBM formats. 2. Image processing - manipulate the image data to produce many effects including scaling, contrast and gamma adjustment, edge detection, etc. 3. Export - write images in popular formats for use with other software. NETPBM uses three intermediate formats: PBM = `portable bitmap' (black&white) PGM = `portable gray map' (greyscale, usually 8bit) PPM = `portable pix map' (color, usually 24bit) The formats are upward compatible, PGM programs can read both PBM and PGM and write PGM, PPM programs can read all three and write PPM. There are also PNM programs (PNM = `portable anymap'), these work on all three formats. The difference between PPM and PNM programs is that PPM programs always write PPM, but PNM programs can write any of the three formats (usually they write the same format as they got as input). There is no PNM format! The great advantage of using intermediate formats is that for a conversion between N formats only 2*N converters are needed instead of N^2; and if yet another graphic format appears, all that is needed are the newtop?m and p?mtonew filters, and you are immediately able to convert the new format to and from any other old format. The disadvantage is that two commands are needed to convert an image: giftoppm mypic.gif >mypic.ppm ppmtoilbm -hamif mypic.ppm >mypic.iff or on Unix-like shells: giftoppm mypic.gif | ppmtoilbm > mypic.iff Another disadvantage is that the intermediate formats are very simple and therefore the files get quite big, for example a 1024x768 PPM picture needs 1024*768*3 bytes = 2.25MB. NETPBM also includes a lot of tools that manipulate the intermediate formats in some way: scaling, rotating, reducing the number of colors and more. For example, to convert a GIF of any size to a 320*200 IFF-ILBM you could do this: giftoppm mypic.gif >mypic.ppm pnmscale -xysize 320 200 mypic.ppm >mypic.ppm2 ppmtoilbm -hamif mypic.ppm2 >mypic.iff or giftoppm mypic.gif | pnmscale -xysize 320 200 | ppmtoilbm -hamif >mypic.iff If you are not using an Unix-like shell, you can use the PIPE: handler to avoid using temporary files: run giftoppm mypic.gif >pipe:1 run pnmscale -xysize 320 200 pipe:2 run ppmqvga pipe:3 ppmtoilbm -aga mypic.iff Requirements ------------ * OS 2.04 or higher, or 1.3 with disk-based mathieeesingbas/mathieeesingtrans libraries (available from C=). * mathtrans, mathieeedoubbas and mathieeedoubtrans libraries in LIBS: A hard disk, a fast CPU, and lots of memory are recommended. It will work on 68000's if you have sufficient memory; on machines with 020+MMU, non-EC 030, or non-EC 040, a virtual memory program like GigaMem will be useful if you are processing large images. A full binary installation takes 1MB of HD space for merged binaries, 3MB for separate binaries (see below for an explanation). Source (not including libtiff source, unix nroff manuals and the vms subdir) takes another 3MB. There is no special 68020/881 binary distribution. The FPU is already used by the math libraries, and most programs are I/O-bound instead of CPU-bound. Merged binaries vs Separate binaries ------------------------------------ Netpbm consists of more than 130 programs, each being stand-alone and not depending on the other programs. This means a lot of disk space is wasted, since all programs use the same routines for reading, writing, allocation etc., and the code for these routines has to be in every single program. To avoid this, the programs can be merged into a single huge executable (actually four of them) and the individual programs are just hardlinks to this binary. Both methods have advantages and disadvantages: Separate binaries: + executables can be individually tuned for maximum performance (register args and small data model are used whenever possible). + most executables are "pure" and can be made resident - full installation takes MUCH more disk space (3MB) Merged binaries: + only 4 executables and a bunch of links. Requires only 1MB of disk space for a full installation. - executables are slower, since all have to be compiled with stack-args and large data model - executables are huge and require more RAM to execute. This will be fixed in the future by using overlays. Why no shared library? Its just too much work. If you think your life depends on having a pbm.library, go ahead and create it... or pay me for a month or two of full-time work, and I'm doing it :-) Installation ------------ Separate binaries: You need the following archives: pbmbin, pgmbin, ppmbin1, ppmbin2, pnmbin. Extract the programs that you need from the archives and copy them to a directory in your search path. Merged binaries: You only need the mergedbin archive. Extract the four p?mmerge programs and copy them to a directory in your search path. Then CD to this directoy and execute the "link_merged" script. This generates all the hardlinks. Links are not supported by 1.3, so if you are still running it, you have no choice but to use the separate binaries. Some 2.x and 3.x filesystems have bugs with links that trashes the disk if the original file is deleted and a link still exists. A safe way is to use the merged binaries on these systems is to install them in their own directory, and if you decide one day to de- install them do it in this way: delete ~(#?merge) delete #? X11 color names file: Some programs (for example pgmtoppm and ppmmake) can use a color names file, so you can specify colors by names instead of RGB values. An example color names file is included in the texts archives, as "RGB.txt". Just copy the file to a convenient place (S: is a good choice) and set the environment variable "RGBDEF" to the full path and name of this file: setenv RGBDEF "s:RGB.txt" Unix shell scripts: I didn't bother to convert the scripts to AmigaDOS-scripts (it's almost impossible anyway). If you want to run them, use a Bourne-shell or Csh clone. Stack size: Don't worry about it. The programs automatically allocate a larger stack if they need more. Memory usage ------------ You can control the way how the programs allocate their memory with the environment variable "PBMMEM". The following keywords are used: fast The programs will not try to allocate chipmem if they run out of fastmem. If this keyword is not used, then the programs will allocate both fast- and chipmem (fastmem first). pool pool= With this keyword, the programs use memory pools. This is faster and avoids run-time memory fragmentation, but unfortunately crashes if used with GigaMem. Note that OS 3.x is *NOT* required, it works under 2.x (tested on 2.1) and probably even under 1.3 (not tested). The optional number selects the size of the pools, the default being 32K. If this keyword is not used, all allocations are done with normal AllocMem() calls. This should work on all systems and with virtual memory programs like GigaMem. max= The maximum memory a program allocates. This does not include the memory used for the code, data and stack segments. The default value (if this keyword is not used) is "unlimited" (2GB, to be precise). Multiple keywords are delimited by whitespace or commas. Numbers can be in decimal, hex (prefix "0x") or octal (prefix "0") and can be given in bytes, Kbytes (suffix "k") or megabytes (suffix "m"). Example: setenv PBMMEM "pool=64k,fast,max=2M" Selects allocation via memory pools, fast memory only, and sets the poolsize to 64KB and the maximum memory usage to 2MB. Misc info --------- NETPBM does not include converters for JPEG, but the freely distributable programs "djpeg" and "cjpeg" can convert JPEG to and from P?M. You can get them from Aminet:/pub/aminet/gfx/conv, look for an archive called "jpegV?.lha" or "AmigaJPEG?.lha" or something similar. The hpcdtoppm included in NETPBM converter is an older version, an up-to-date version is available on Aminet:/pub/aminet/gfx/pbm, archive "hpcdtoppm*.lha". All programs have two hidden options, "-version" and "-quiet". The first does the obvious: it prints version and configuration information of the program. The other suppresses all messages from the program (unfortunately, some programs ignore this option). Most programs print usage information if a "-?" option is given. Support ------- Your can reach me via E-mail: Ingo.Wilken@informatik.uni-oldenburg.de IRC: Nobody (usually on channel "#amigager") Carrier pigeon and other ancient communication channels: Ingo Wilken Bloherfelder Str. 72 26129 Oldenburg W-Germany For bug reports, please describe exactly what you were doing, what went wrong (guru number?) what OS version you are using, your machine configuration, and everything else that could be important. If possible, provide the following: * "enforcer" & "mungwall" output * "showconfig" output * a sample image that triggers the bug (unless it appears with any image) * the output of running the NETPBM-program with the -version option Also, make sure that it's really the NETPBM-program thats causing the problems, not some background-utility playing corewar. netpbm-8.2/amiga/compat.amiga0100640000076400000000000000172103631424022015222 0ustar bryanhroot; compat.amiga - AmigaShell aliases to allow users of old versions of PBM ; to keep their habits. alias giftoppm "giftopnm" alias pbmcatlr "pnmcat -lr" alias pbmcattb "pnmcat -tb" alias pbmcrop "pnmcrop" alias pbmcut "pnmcut" alias pbmenlarge "pnmenlarge" alias pbmfliplr "pnmflip -lr" alias pbmfliptb "pnmflip -tb" alias pbmpaste "pnmpaste" alias pbmtops "pnmtops" alias pbmtorast "pnmtorast" alias pbmtoxwd "pnmtoxwd" alias pbmtrnspos "pnmflip -xy" alias pcxtopbm "pcxtoppm" alias pgmtops "pnmtops" alias picttopbm "picttoppm" alias ppmarith "pnmarith" alias ppmconvol "pnmconvol" alias ppmcscale "pnmdepth" alias ppmrotate "pnmrotate" alias ppmscale "pnmscale" alias ppmshear "pnmshear" alias ppmsmooth "pnmsmooth" alias ppmtops "pnmtops" alias ppmtorast "pnmtorast" alias ppmtoxwd "pnmtoxwd" alias rasttopbm "rasttopnm" alias rasttoppm "rasttopnm" alias tifftopbm "tifftopnm" alias tifftopgm "tifftopnm" alias xwdtopbm "xwdtopnm" alias xwdtoppm "xwdtopnm" netpbm-8.2/amiga/DICE.PATCH0100640000076400000000000000215303631424022014224 0ustar bryanhroot*** ppm/ppmforge.c.old Mon Oct 04 10:12:28 1993 --- ppm/ppmforge.c Thu Feb 10 01:06:08 1994 *************** *** 662,670 **** --- 662,676 ---- AtSat(ib, 255); inx = PlanetAmbient + (1.0 - PlanetAmbient) * di; + #ifndef _DCC ir *= inx; ig *= inx; ib *= inx; + #else + ir = ir * inx; + ig = ig * inx; + ib = ib * inx; + #endif /* _DCC */ } PPM_ASSIGN(*rpix, ir, ig, ib); *** ppm/picttoppm.c.old Fri Jan 28 10:19:18 1994 --- ppm/picttoppm.c Thu Feb 10 00:59:44 1994 *************** *** 3008,3017 **** --- 3008,3024 ---- double xscale; double yscale; { + #ifndef _DCC r->left *= xscale; r->right *= xscale; r->top *= yscale; r->bottom *= yscale; + #else + r->left = r->left * xscale; + r->right = r->right * xscale; + r->top = r->top * yscale; + r->bottom = r->bottom * yscale; + #endif /* _DCC */ } static void netpbm-8.2/amiga/dice_stack.c0100640000076400000000000000007303631424022015173 0ustar bryanhrootlong _stack_fudge = 16*1024; long _stack_chunk = 32*1024; netpbm-8.2/amiga/link_merged0100640000076400000000000001530703631424021015146 0ustar bryanhroot; this script creates the hardlinks for merged binaries ; it must be executed in the directory where the merged binaries are makelink from atktopbm to pbmmerge hard makelink from brushtopbm to pbmmerge hard makelink from cmuwmtopbm to pbmmerge hard makelink from g3topbm to pbmmerge hard makelink from icontopbm to pbmmerge hard makelink from gemtopbm to pbmmerge hard makelink from macptopbm to pbmmerge hard makelink from mgrtopbm to pbmmerge hard makelink from pbmclean to pbmmerge hard makelink from pbmlife to pbmmerge hard makelink from pbmmake to pbmmerge hard makelink from pbmmask to pbmmerge hard makelink from pbmpscale to pbmmerge hard makelink from pbmreduce to pbmmerge hard makelink from pbmtext to pbmmerge hard makelink from pbmto10x to pbmmerge hard makelink from pbmto4425 to pbmmerge hard makelink from pbmtoascii to pbmmerge hard makelink from pbmtoatk to pbmmerge hard makelink from pbmtobbnbg to pbmmerge hard makelink from pbmtocmuwm to pbmmerge hard makelink from pbmtoepsi to pbmmerge hard makelink from pbmtoepson to pbmmerge hard makelink from pbmtog3 to pbmmerge hard makelink from pbmtogem to pbmmerge hard makelink from pbmtogo to pbmmerge hard makelink from pbmtoicon to pbmmerge hard makelink from pbmtolj to pbmmerge hard makelink from pbmtoln03 to pbmmerge hard makelink from pbmtolps to pbmmerge hard makelink from pbmtomacp to pbmmerge hard makelink from pbmtomgr to pbmmerge hard makelink from pbmtopi3 to pbmmerge hard makelink from pbmtopk to pbmmerge hard makelink from pbmtoplot to pbmmerge hard makelink from pbmtoptx to pbmmerge hard makelink from pbmtox10bm to pbmmerge hard makelink from pbmtoxbm to pbmmerge hard makelink from pbmtoybm to pbmmerge hard makelink from pbmtozinc to pbmmerge hard makelink from pbmupc to pbmmerge hard makelink from pi3topbm to pbmmerge hard makelink from pktopbm to pbmmerge hard makelink from xbmtopbm to pbmmerge hard makelink from ybmtopbm to pbmmerge hard makelink from bioradtopgm to pgmmerge hard makelink from fstopgm to pgmmerge hard makelink from hipstopgm to pgmmerge hard makelink from lispmtopgm to pgmmerge hard makelink from pbmtopgm to pgmmerge hard makelink from pgmbentley to pgmmerge hard makelink from pgmcrater to pgmmerge hard makelink from pgmedge to pgmmerge hard makelink from pgmenhance to pgmmerge hard makelink from pgmhist to pgmmerge hard makelink from pgmkernel to pgmmerge hard makelink from pgmnoise to pgmmerge hard makelink from pgmnorm to pgmmerge hard makelink from pgmoil to pgmmerge hard makelink from pgmramp to pgmmerge hard makelink from pgmtexture to pgmmerge hard makelink from pgmtopbm to pgmmerge hard makelink from pgmtofs to pgmmerge hard makelink from pgmtolispm to pgmmerge hard makelink from psidtopgm to pgmmerge hard makelink from rawtopgm to pgmmerge hard makelink from spottopgm to pgmmerge hard makelink from fitstopnm to pnmmerge hard makelink from giftopnm to pnmmerge hard makelink from pnmalias to pnmmerge hard makelink from pnmarith to pnmmerge hard makelink from pnmcat to pnmmerge hard makelink from pnmcomp to pnmmerge hard makelink from pnmconvol to pnmmerge hard makelink from pnmcrop to pnmmerge hard makelink from pnmcut to pnmmerge hard makelink from pnmdepth to pnmmerge hard makelink from pnmenlarge to pnmmerge hard makelink from pnmfile to pnmmerge hard makelink from pnmflip to pnmmerge hard makelink from pnmgamma to pnmmerge hard makelink from pnminvert to pnmmerge hard makelink from pnmhistmap to pnmmerge hard makelink from pnmnlfilt to pnmmerge hard makelink from pnmnoraw to pnmmerge hard makelink from pnmpaste to pnmmerge hard makelink from pnmrotate to pnmmerge hard makelink from pnmscale to pnmmerge hard makelink from pnmshear to pnmmerge hard makelink from pnmtile to pnmmerge hard makelink from pnmtoddif to pnmmerge hard makelink from pnmtofits to pnmmerge hard makelink from pnmtops to pnmmerge hard makelink from pnmtorast to pnmmerge hard makelink from pnmtosgi to pnmmerge hard makelink from pnmtosir to pnmmerge hard makelink from pnmtotiff to pnmmerge hard makelink from pnmtoxwd to pnmmerge hard makelink from rasttopnm to pnmmerge hard makelink from sgitopnm to pnmmerge hard makelink from sirtopnm to pnmmerge hard makelink from tifftopnm to pnmmerge hard makelink from xwdtopnm to pnmmerge hard makelink from zeisstopnm to pnmmerge hard makelink from bmptoppm to ppmmerge hard makelink from gouldtoppm to ppmmerge hard makelink from ilbmtoppm to ppmmerge hard makelink from imgtoppm to ppmmerge hard makelink from hpcdtoppm to ppmmerge hard makelink from mtvtoppm to ppmmerge hard makelink from pcxtoppm to ppmmerge hard makelink from pgmtoppm to ppmmerge hard makelink from pi1toppm to ppmmerge hard makelink from picttoppm to ppmmerge hard makelink from pjtoppm to ppmmerge hard makelink from ppm3d to ppmmerge hard makelink from ppmbrighten to ppmmerge hard makelink from ppmchange to ppmmerge hard makelink from ppmdim to ppmmerge hard makelink from ppmdist to ppmmerge hard makelink from ppmdither to ppmmerge hard makelink from ppmflash to ppmmerge hard makelink from ppmforge to ppmmerge hard makelink from ppmhist to ppmmerge hard makelink from ppmmake to ppmmerge hard makelink from ppmmix to ppmmerge hard makelink from ppmnorm to ppmmerge hard makelink from ppmntsc to ppmmerge hard makelink from ppmpat to ppmmerge hard makelink from ppmquant to ppmmerge hard makelink from ppmqvga to ppmmerge hard makelink from ppmrelief to ppmmerge hard makelink from ppmshift to ppmmerge hard makelink from ppmspread to ppmmerge hard makelink from ppmtoacad to ppmmerge hard makelink from ppmtobmp to ppmmerge hard makelink from ppmtogif to ppmmerge hard makelink from ppmtoicr to ppmmerge hard makelink from ppmtoilbm to ppmmerge hard makelink from ppmtomap to ppmmerge hard makelink from ppmtomitsu to ppmmerge hard makelink from ppmtopcx to ppmmerge hard makelink from ppmtopgm to ppmmerge hard makelink from ppmtopi1 to ppmmerge hard makelink from ppmtopict to ppmmerge hard makelink from ppmtopj to ppmmerge hard makelink from ppmtopjxl to ppmmerge hard makelink from ppmtopuzz to ppmmerge hard makelink from ppmtorgb3 to ppmmerge hard makelink from ppmtosixel to ppmmerge hard makelink from ppmtotga to ppmmerge hard makelink from ppmtouil to ppmmerge hard makelink from ppmtoxpm to ppmmerge hard makelink from ppmtoyuv to ppmmerge hard makelink from ppmtoyuvsplit to ppmmerge hard makelink from qrttoppm to ppmmerge hard makelink from rawtoppm to ppmmerge hard makelink from rgb3toppm to ppmmerge hard makelink from sldtoppm to ppmmerge hard makelink from spctoppm to ppmmerge hard makelink from sputoppm to ppmmerge hard makelink from tgatoppm to ppmmerge hard makelink from ximtoppm to ppmmerge hard makelink from xpmtoppm to ppmmerge hard makelink from xvminitoppm to ppmmerge hard makelink from yuvtoppm to ppmmerge hard makelink from yuvsplittoppm to ppmmerge hard netpbm-8.2/amiga/README.DICE0100640000076400000000000001057605534461530014343 0ustar bryanhrootThis file describes how to compile NETPBM with DICE (registered version). You need a real "make" program (the "dmake" supplied with DICE won't work for this), and "patch". The "make" program should ignore a WARN return code. Compilation requires about 4MB RAM and 6MB of HD space, and takes about 45 minutes on a 25MHz 68030. Compilation of the TIFF library is not covered in this file. A compiled TIFF lib is available in the dicelibs archive (see "NETPBM.INTRO" for FTP addresses). Copy this library to the netpbm/libtiff directory. (1) CD into netpbm/amiga and compile dice_stack.c with dcc -c dice_stack.c (2) Set the environment variable "USER" to your name, like this: setenv USER "Al Bundy" CD into the toplevel netpbm directory and execute the shell-script "stamp-date.amiga". This will create the file "compile.h". (3) Apply the patch: patch -l < amiga/DICE.PATCH This installs a workaround for a DICE bug in two source files. If you are using a DICE version newer than 2.07.56R, this bug might already be fixed. To test this, compile this program: main() { double d = 0.5; int i = 2; i *= d; printf("%d\n", i); } If the result is "0", the bug still exists. (4) Edit pbmplus.h. The following symbols should be set: A_SMALLSTACK (obsolete, no longer used) A_FRAGARRAY A_RGBENV (optional, but recommended) A_STRERROR (5) There is no toplevel Makefile. CD into netpbm/pbm and type make -f Makefile.dice all for separate binaries or make -f Makefile.dice merge for a merged binary (see "NETPBM.INTRO") Repeat this in the directories netpbm/pgm, netpbm/ppm and netpbm/pnm, in this order. If you are changing the compiler options, make sure to change them in all four makefiles. (6) The binaries are now in netpbm/p?m/bin, just move them to a directory in your search path. See the file "NETPBM.INTRO" for more installation info. Note that binaries created by you will not use the PBMMEM environment variable. Here is a short explanations of compiler options used in the DICE Makefiles: -E xxx write error messages into file xxx -ms place strings constants in read-only code hunk -mu unix-compat, if there are two definitions for the same variable (at the same scope), merge them into one -gs generate stack-checking code (see dice_stack.c: whenever available stack falls below _stack_fudge, allocate a new stack of size _stack_chunk) -proto strict prototype checking -mRR functions take their args in registers (requires full prototyping) -mD large data model (absolute addressing instead of A4-rel) -mC large code model (absolute addressing instead of PC-rel) -r generate "pure" executable (no -mD and -mC allowed) -S alternate library section naming (used for link libs only) -s DEBUG: don't strip symbol information from executable -d1 DEBUG: include LINE information in executable (for Enforcer's FindHit) Naming conventions in the Makefiles: RLIBP?M small data library, args in registers RLLIBP?M large data library, args in registers SLIBP?M small data library, args on stack SLLIB?M large data library, args on stack RALLCFLAGS options to compile register-args executables SALLCFLAGS options to compile stack-args executables MALLCFLAGS options to compile merged executable BINS small data executables, register-args LBINS large data executables, register-args SBINS small data executables, stack-args SLBINS large data executables, stack-args MATHBINS \ LMATHBINS \ same as above, but need floating-point SMATHBINS / version of printf/scanf (link with math-lib) SLMATHBINS / *.or library object file (small data, reg-args) *.os library object file (small data, stack args) *.olr library object file (large data, reg-args) *.ols library object file (large data, stack args) *.om object file for merged binary (large data, stack args) I tried to use small data/reg-args whenever possible. Some programs had to be compiled with large data, and some with stack-args or the compiler would complain. -Ingo email: Ingo.Wilken@informatik.uni-oldenburg.de netpbm-8.2/compat.csh0100660000076400000000000000212105534610762013654 0ustar bryanhroot# compat.csh - csh aliases to allow users of old versions of PBM to keep # their habits. # # This script must be sourced - it will not work if you run it in a sub-shell. alias fitstopgm 'fitstopnm' alias giftoppm 'giftopnm' alias pbmcatlr 'pnmcat -lr' alias pbmcattb 'pnmcat -tb' alias pbmcrop 'pnmcrop' alias pbmcut 'pnmcut' alias pbmenlarge 'pnmenlarge' alias pbmfliplr 'pnmflip -lr' alias pbmfliptb 'pnmflip -tb' alias pbmpaste 'pnmpaste' alias pbmtops 'pnmtops' alias pbmtorast 'pnmtorast' alias pbmtoxwd 'pnmtoxwd' alias pbmtrnspos 'pnmflip -xy' alias pcxtopbm 'pcxtoppm' alias pgmtofits 'pnmtofits' alias pgmtops 'pnmtops' alias picttopbm 'picttoppm' alias ppmarith 'pnmarith' alias ppmconvol 'pnmconvol' alias ppmcscale 'pnmdepth' alias ppmrotate 'pnmrotate' alias ppmscale 'pnmscale' alias ppmshear 'pnmshear' alias ppmsmooth 'pnmsmooth' alias ppmtops 'pnmtops' alias ppmtorast 'pnmtorast' alias ppmtoxwd 'pnmtoxwd' alias rasttopbm 'rasttopnm' alias rasttoppm 'rasttopnm' alias tifftopbm 'tifftopnm' alias tifftopgm 'tifftopnm' alias xwdtopbm 'xwdtopnm' alias xwdtoppm 'xwdtopnm' netpbm-8.2/compat.ksh0100660000076400000000000000212105534611024013654 0ustar bryanhroot# compat.ksh - ksh aliases to allow users of old versions of PBM to keep # their habits. # # This script must be sourced - it will not work if you run it in a sub-shell. alias fitstopgm='fitstopnm' alias giftoppm='giftopnm' alias pbmcatlr='pnmcat -lr' alias pbmcattb='pnmcat -tb' alias pbmcrop='pnmcrop' alias pbmcut='pnmcut' alias pbmenlarge='pnmenlarge' alias pbmfliplr='pnmflip -lr' alias pbmfliptb='pnmflip -tb' alias pbmpaste='pnmpaste' alias pbmtops='pnmtops' alias pbmtorast='pnmtorast' alias pbmtoxwd='pnmtoxwd' alias pbmtrnspos='pnmflip -xy' alias pcxtopbm='pcxtoppm' alias pgmtofits='pnmtofits' alias pgmtops='pnmtops' alias picttopbm='picttoppm' alias ppmarith='pnmarith' alias ppmconvol='pnmconvol' alias ppmcscale='pnmdepth' alias ppmrotate='pnmrotate' alias ppmscale='pnmscale' alias ppmshear='pnmshear' alias ppmsmooth='pnmsmooth' alias ppmtops='pnmtops' alias ppmtorast='pnmtorast' alias ppmtoxwd='pnmtoxwd' alias rasttopbm='rasttopnm' alias rasttoppm='rasttopnm' alias tifftopbm='tifftopnm' alias tifftopgm='tifftopnm' alias xwdtopbm='xwdtopnm' alias xwdtoppm='xwdtopnm' netpbm-8.2/testimg.ppm0100640000076400000000000030615407061065526014076 0ustar bryanhrootP6 227 149 255 0/-0/-10.21/51.51.62/62/83/83/:3-:3-:3-:3-:3-:3-:2/91.91.80-80-91.91.:2/80-80-80-80-80-80-80-80-6.+6.+6.+5-*5-*4,)4,)4,)4,)4,)4,)4,)4,)4,)4,)2-)/*$/,%/,%0-&1.'2/(30)30)63,63,74-85.85.96/:70:7.A:0B<0D>2F@4IA4JB5KC6KC6MD5MD5OC3NB2OC3OC3PD4RE5R?1Y?2b@4nB5}E6H8G9F7G:G9E:G;G>G?H@E@FLCLDKEICIBD>B=A;A:@:??-?/?/>.>,=+<+<+?+?+=*=*=*>+?,@/?6>5=2?1B3D3D4D4?0A2F8H;H9oA2T8*C3&=5295495473271160050-50-72/72/72/61.61-50,50,41,//-.0-//-//-0/-0/-2.-2.-5,-4+,4*+3)*7(+=.1E69P:0U?1^A3jC4xD6E4E5C3C4A4A4B7D:E@<@6>/@.?-?-?-?,?-@-@,@+A-A+@*A)@*A,>-?/>.>.>,=+<+<+?+>*=*=*=*>+?,@/@5>5>3>1A3D4C4D5A2C6F8I;G:l@3S9*B4)>63:6595484382271161.61.72/72/72/61.61-50,50,41,//-.0-//-//-0/-0/-2.-2.-3--5,-4*+3)*5)+<-0C47N8:d>=vEAJINLTVajl}r{{ou[[QHuOCiOFeOG_PH_RN_[Yfnot~ojkY][LVSJXSZVRaXQa/.,/.,0/-10.40-40-51.51.72.72.72.72.92,92,92,92,91.80.7/-7/-7/-7/-80.91/80.80.80.80.80.80.80.80.6.,5-+5-+5-+4,*4,*4,*4,*5-+5-+5-+5-+5-+5-+5-+3.*2-'1.'2/(30)30)41*41*52+63,63,63,74-85.96/96/:7.?8.@:.B<0D>2G?4H@5H@3H@3I@1I@1K?1K?1K?/L@0MA1NB2MA1QA1YB2dC2qC3|C2B2A0<-:+;.=2@6D:F=D>CE@FBGBFDFCEAD?D;@:?;@=@@@A=@;@5=.@-@-?,?-?->,@,?-@-@,A+A,?*@*@+>->.>.>.=+=+=+=+>,>,<+<+=,=,?+?.A6?5>3>2A4C5D5C5D8F;I=J=G;h@4Q:,B5,?74=77<66:4494183072/72/62/62/62/51.52-41,41,21,.0-,1-.0-.0-//-//-0/-2.-5//4..5,-4*+4*+9-/>24I56[97l?9|E@IDOM[`fvmw}}u~fmTVMEvLAkMAeOFcQHcMH^NK\[[eqty|xzlfiXZ[MVSLZU[ZT`[S`.-+/.,/.,0/-3/,40-40-40-61-61-61-61-81+81+81+81+7/-7/-6.,6.,6.,6.,7/-7/-80.80.80.80.80.80.80.80.5-+5-+5-+4,*4,*4,*3+)3+)6.,6.,6.,6.,6.,6.,6.,4/,30+30)30)41*41*52+52+52+52+52+63,74-85.85.96/96->7-?9-@:.B<0E=2E=2F>1F>1G=1G>/H<.I=/I=/J>.L@0JA0KD2NE4UD4^D3iD2sB1~A/?-9)9'9*<-@3E8HDCACBCDCCDBC@C?A;@:?;@>@A@B=@9@3=-@,@,@,>,?,?,?+@-?,@+@*@+@*@)?*>,>.>.=-=+=+<*<*=+=+<*<*<+>,>-?-A6?5>2@4B6C8C7B7F|F:b@4L:.A7-@85>96=77<74:5294183083062/62/62/32.52-21,21,12--2.-2./1./1.00.00.10.10.5106005//5,-4+,6,-:01D22T71c;3qA7{E;HDRU_lis}yx}ow`fQRLEyL@pL@hPEgQFfLC^GBVMLZ^^fjnquyxx}wzvwzokoa`bTWYLTTL]WY]V]]V^------.-+/.,0/-10.3/,40-3/,3/,4/+4/+4/+4/+6/)6/)4/,4/,3.+3.+3.+3.+4/,4/,50-50-50-50-50-50-50-50-3.+3.+2-*2-*2-*1,)1,)1,)4/,4/,4/,4/,4/,4/,4/,4/,41,41,41,41,41,52-52-52-52-52-63.63.74/85096196/<5-=6,?8.@9/B:/C;0C;0C;.D:.D:.F:.G;-H<.I=/J>0I@1JG6MH5RG5YF5bE3jD1uB/}>,;):):*=,B2F8J=I?GBDCDBEBBBAA=@<>:?:<<>?>B>C:A5?0?-?,?,?,>->->-?->.?-?,?+?,?+>*>*>,?.>->->-=,=,=,=,=,=,=,<,>->.?.B4A4@1@3A7C9B8A7C;H?LCJ@tE;Z>2E9-<5+@93@85?75>63=52<4194083/62/43/43/23.32.12-12-02--2.,2.-2.-2./1./1.00.10.3205105104..2,,4+,7./=/.N5.Y9.e=1n@3sB;yKKZegpzxu{ks_dTTOGLBwNAmNBhMAeJA`GBYGFXKKWMPU]cc`fbbia`f\Z`TW[MUXMXXP^YV`WX`WZ,,,,,,.-+.-+/.,0/-3/,3/,2.+2.+3.*3.*3.*3.*5.(5-*3.+3.+2-*1,)1,)2-*3.+3.+3.+3.+3.+3.+3.+3.+3.+3.+2-*2-*2-*2-*1,)1,)1,)0+(3.+3.+3.+3.+3.+3.+3.+3.+41,41,41,41,41,41,41,41,41,52-52-63.74/85085085.;4,<5+=6,>7-@7.A9.A9.A9.C9/C9-E9-F:.G;/H<.J>0HA1JG6IH6NG5VF6\E3dC2n@0v>-{<+;);*=,@1F5J:J=H@EAFAE@CA@>>?:<;<:;<=@=C=C8@2>,?,@,?+?+?->,>,?,>-?,?,>,?+>*>)?*>+>->->-=,=,=,<+=,<+<+<+<-=,>/?.B4A2@2B5C9C:B:A;A9I@NGNEoG=S?4A;/96-@93A75?74>63<4194083/74/43/43/34/23.23.02-02-.3--3/-3/.3/.3/02/02/11/11/21/32032040/2.-1-,4..8.,G4-O4)X8+`<0e?6mGFyYdku||w|nudh[[RMLB~OArL@hI=cH>`HB^ECX@BO;@FBGJDMJJQJJQIIQFKQEOUIVWO^YS`YS`XU++++++,,,---/.,/.,0/-0/-1-*1-*1-*1-*2-)2-)2-)2-)2-*2,,1++1++1++1++2,,2,,1++1++1++1++1++1++1++1++2,,2,,2,,1++1++1++0**0**3--3--3--3--3--3--3--3.+41,41,41,30+30+30+30+30+41,41,52-63.74/74/85085.:3+;4,<5-=6.?6/?6-?6-?7,B8.B8.E8/E9-G;/H<0J>2H@3HE6GF4KE5QD4XC2_B2f?.n=,v=,|:*9);*=.B2F7F8FF>E>D@C?@@>>::;:<.>.=->-=.?.?-?-?,>*?*>)>+>->-=,=.=.<-<-<-=-;,<,.=0?/C2B1A1B6C:CCC793@72>71=60:5/94.83/63.43.43.34/13.13..3-.3-.3--3/-3/-3/-3/.3/.3/02/02/00.11/22021/0/-/.,2.-4/,?0+D0)K3)T8-Z<4dFFu]js~tzmpceVSLCK?qI_FB]DBW?AN;?H:BE>HGDMHGQIGQHJRGNVKUXM^ZOaYNaXO++++++,,,,,,.,-/.,0/-0/-1-*1-*1-*1-*2-)2-)2-)2-*2,,1++1++0**0**1++1++2,,0**0**0**0**0**0**0**0**2,,2,,2,,1++1++0**0**0**2,,2,,2,,2,,2,,2,,2,,2,,3/,30+30+30+30+30+30+30+41,41,52-63.63.74/85085092,:3+;4,<5->5.>5.>5.>5,B8/B8.E8/E8/G:1I=1J>2I?3FC4FC4JB5OA4TA2\@2b>0j<-q<.w9*}8)8(:,=/B4B5F:E;F>G?G@FACAB@;;;;>;B;D:D4@->(A-A-@,@.@.?-?->/>.@.?.?->+?*>)>+>->->-=,=.<-<-=-=-<.<.<./>1?1D2C1B4C6C;D>D>EAPL[Te\f]u_T[UIGMACI?<92?82>71;6094.74-63.43.43.34.24/13./4..3-.3-.3--3/-3/-3/-3/.3/.3/02/02///-00.22022010.0/-0/-3/,8,,;,)C0*K70S<6^IHtbnzƄzrxikWWIDE=nG^CAY@CV@DP>EKGQRKWUQ^WU`XS_UR^TT^SY_S^[LaZJaZJ,-/,-/,-/,.-------.-+.-+/.,/.,1-*0,)0,)0,)/+(/+(/+*/+*/+*/+*/+*/+*/+*0,+/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*0,+0,+1-,1-,2.-1-,1-,1-,1-,1-,1-,1-,1-,0,)1-*2.+3/,3/,3/,3/,3/,3/,3/,3/,3/,40-51.62/74/80-92,:3-;4.=4/>5.>5.>5.?4.?5,B5-C6.D7/F90G:1F<2G?4H@5J@6P?5T>3X<1^90b6+m9.t8-|8+9,;/=0?1>0A3A4C8E:G=G>E?C@@?BADAE>D8B1A.B,A.@-?,>.=-=->.?/<,=,<->-=,=+=*>*<+<+=-<,<,<,:-;-=/3@2A5A4E5D4E9I>G@D>EAMGZRf_qfsh~rdjj^V^SIQFLLBJF=B>5<8/95,74+63,33+43.34.14-14-02-/1,,1+,1+-2.-2.-2.-2./1./1./1./1.02/02/11/11/11/11/11/40/4+0;/3A32C4/J;6]OOymyϐكtzjn_bZ[LItHBdA>]>>X?BUAIVLU\U`bbqnn}xv|rulyoguh_k_W_P]\Hb\Fc]G,-/,-/,-/,-/------.,-.-+/.,.-+0,)0,)/+(/+(/+(/+(.*).*).*).*)/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*0,+0,+0,+1-,1-,1-,1-,1-,1-,1-,1-,1-,1-,0,+0,)1-*2.+3/,3/,2.+2.+2.+2.+2.+2.+3/,40-51.62/80.91.:2/;4.=4/>50>50=4-?4.?4.A4.B5-C6.E80G:2H;3H>5H>5L=6O>6Q=4V;2Z90_7/h70p7.w7-9-9.<1<1=1@3A3B5D8E:FF8C2B-B-C.B-@.?-?-?->.>.=,>,=-=,=+>+>*=,<+=+<,<,<,;+;-<-2@6A7B6G9E7G->->->/?0<-=-<.=.>-=,<+=+<*<*<,;+;-<-:-;-<0<0<2>3?4A8C:D9J=H;H>KDKFLGSM`Vsgqz{wsocqbXcUNRDMN@HI;DD8@@49;.46+/1&01)01)/0*/0*./*./*//-//-//-.0-//-//-//-//-//-//-00.00.00.00.00.00.00.1/26+97+98/4;63HE>_^Yzz|DŽ}{|}}wq~n}n~~o~y|{j{i\hTXX@]Y<_[@-.0-.0-.0-.0-.0-.0.......-+.-+-,*-,*.*'.*'.*'.*),*++)*+)*+)*+)**()*()*(),*+,*+,*+,*+,*+,*+,*+,*+,*+,*+,*+,*+,*+-+,-+,-+,-+,.,-.,-.,-.,-/-./-./-./+*0,+1-,1-,1-,1-,0,+0,+0,+0,+0,+0,+1-,2.-3/.40/91/:20;31<41=31=31=31=4/>3/>3/@2/@3-A4.C60D71E82F93H94I:5J;6L:6N94Q83T50^72e60o6/x8/90:/<1>1?4?4?2?1A2B5D7E:G>H@JAI>F:B5A0@.A-A-?->,>,>,=.>.<,=,=.=-=,=+=-<,;););+;+;,;,;-;,;/<1<1>5@7C:DJCLIQL]Vj^oyzxm{jbm]SZJQUFKO@EI:@D6;=057,13(01)/0(./).-(.-).-)/.,0/-/.,/.,/.,/.,/.,..,/.,..,0/-//-0/-//-//-//-//-2-17,:6*83-1961HJ?bfX{z}|k|iXfOSV;ZV9^Z=+/2+/2+/2+/2-.0-.0......------.-+-,*-,*,+),+),+),*+,*+,*++)*+)**()*()*(),*+,*+,*+,*+,*+,*+,*+,*+,*+,*+,*+,*+,*++)*+)*+)*,*+-+,-+,.,-.,-/-./-./-./+*0,+0,+0,+0,+0,+/+*.*)/+*/+*/+*/+*0,+1-,3/.40/901:20;31<42=32=31<20<20=20=2.?1.?1.@2/A30B5/C60D63C84D95E:6G96H94K84N50X72_60i70r7/}:1<1>2>2@6?5?5?3@3C5C6E8E;G=H>G=D8A5?0@/@-@-?.>-=,<,=/=/<.;-0->0-?1.@2/A4.?4.@51@72@93A:4B94C84F74H5/Q51X5/a6/l8-u9.0=1?5>5?5?4B4B4C4D4B5D8E:E;B7?4>1>0?.?+=,=,<+<+<.<.;-<-<.;-;,<,;+;+:*:*9):):+9*9-9-<1<3?6A8CHCNJVR`Zper}~~yup{jdp\]iSR^JJS@BK:>E5:@29<134,22*1.)/,'/))0**1++2,,1++1++1++1++1++0,+0,+0,+1-,1-,1-,1-,/.,/.,/.,2,.8*75(13+(56&EK1\gGudyťέɭʰ˱Ȭ{wrdx]Q_ENR7QQ5SR6,03,03,03,03./1./1./1./1/////////////.,/.,.-+.-+/-..,-.,--+,,*++)*+)**()+)*+)*+)*+)*+)*+)*+)*+)*+)*+)*+)**()*()*())'()'(+)*+)*,*+-+,.,-.,-/-./-./+*/+*/+*/+*/+*.*)-)(,('0,+0,+0,+0,+1-,2.-40/40/:12;23;23<34=32<21<21;10<1/<1/>0/=/.>0->0-?1.>3/=60;60;83<94=:5>93@72C60G4.O4+Y4+d5+n8,x:-;.;.<4<5>3@3A2B1A2@0>1@4B7B9@6>5=2?2?-?->,=+;*;*<-<-;.;.;-;-;.:-:,;,9)9):)9(9*9*~8,~8,<1=4@7B9E>IAKFMFIAH@JFSO]Xhb{ny~wxnjxadr[ZhQQ]IITCCL;>D60-?1.=2.=4-=6.;819919:29:2;81?6/C2+J1,T2)^3*g7+o9-u=.z2B6C7B7?4>2>1>/=.=-<,=,=,=.>/<.<.2>5@6C:G=JBNEOGICIDPJ\Tg`uiu~zytoi}bby]\pUUgOO\HGRAAH8=A388.85.7/,3+)2()2()3)*4*+0*,/+*0*,0**0*,0*,2),2),3*-1+-1+-1+-0,-0,-0,-1+/4)/4*+4-%46!?F%T`8m|Qgtz~z{Ĉːəǝƚ~xvolfZnSJZ?GM3FJ1DF./0+.0+/0+01,01,01,12-21-32.43/43/62/51.41,3/,4/,50-50-4/,3.+2,,1-,0,+0,+.,-.,---/--/,,.++-*).))+.)/.)-/(/.)-/)-.)-.*+.*+/+*/+*-,*.-)--+-.)./*./*------.,-/-./.,0/-2.+2.+2-*4,)5-*6.+8/*:1,:1*;2+=4-=4->50>50>50=4/<3.;2-=2.<1-<1/;0.=/.>0/>0/@1.A0)@2);4*77-39-28.56.:3-?-)F*'L)'S*&Z/(`5,d<0k@0yA0@/A1B3@3=0;/8-;/=.A1B2C2A0>.;,;0:2;1=0?0?/?.>.@1?0>1<0;/:.:-;-{9+~@3w<.q7)w>-w>-v;-}?2{;/@4E9I?LAMBPCNEKISPbYpa}jq|~u{ouiib_[zXZsUZnSWeNPWEJK=C?6@93;0.6**3')3'+3'+1&*,*-)+***,*(),'+.(,1(-2'-3(.3(.3(02(00)10)1/*1/*0/)-1++0-(//#5,>5,>5.>5.>5.=4-<3.<3.=2.<1-;0.;0.=/.=/.>0/@1.C0*C0)A2+>4+:6-95,:3-<1-?-+D*)I*(N+'T/)Z5-_:1e>/pA/xA-A0@2?4=3:2;19..@0A1A1A/?1;2;2<2=0>0@/?/?.@1>/=0<.;.;,:,;,x8,x<1s9-n9+s>.s>.r8*u:,}=1A5E:I=K@NAPCNEJHSRf]wfpww}ovei``YZY{X\wXZnSSaJNUCFH;C@7<737/-3*+2)*1(+.(*,*+**,+),+),-(,/)-2(02(02(02(02(10)1/*1-*3-*3-*12-12.-0,)--%8:,SXBox]iolnpppw{xwy||{xuqnh{eYjWMZHEL<@D5;=/12,12,12,12,23-23-43.43.54/54/85085085074/72.61-80-80-7/,6.+4/,3.+2,,1-,1-./-.0.1/-0--/,,.+*/+)./(/1'//)-/)-/)-/)-.*+.*+0,+0,+/.*/.*/.)0/*0/*0/+//-///0./0./0/-/.,1-*2-*6.+70*90+:1*<1+=3*>4+?5,?6-?6-@7.@7.?6/>5.=4-=4-=2.<1-;0.;0.;0.;0.<1/?1.C2+E0+H/+K--L,/K+.I*/E+.A-,@.*A.(E.(M.)X1*b3-g5,j:,o;-w;0=4<6<5:4:4<2=2>2?3A2A3B5C5?2=/>1>.>/>,=.<,;.<,:-:*;,<)~=+{<+}=1z<1v:/u;/x@1x@1v<.v;-?5B8F=H?JAKANCNFJHTQf\vent{}yximae\a\`]`[|]UrVPhPFYEBP?:D93:2.3,*/)*,)**(0'(1&*1&*1&*0'*1(+0*.0+//*.-+.,+0+,0)-0(-1(-1)-01/23/..*'**"57*PUAmv[|ik~jjnn~mqx|zxvvuwyy}}ywtpmh|cYkUMZHDH9=?299-23-23-34.34.34.45/54/54/650761961:72:72961940940:2/91.91.80-50-4/,4..4..3/03/01/01/20.1..0--/-+.0)02).0*.0*.0*.0*,/+,/+*1-,1-,0/+0/+10+10+10+10,11/1111/010.10.2.+3.+3.*92,92,;2+<3,>4+@6-@6-A7.B8/A8/B90A8/A81@70>5.>5.=2.=2.<1/;0.;0.<1/=20=2.B3.E2.L..R+0V'/U&.P'/I).C/.<1+;2)?2)G0(R/)_.*d/)i9/k;/u<3}<6;8;9;7:6>8@8B9B9C7B7A7A5@1A/@.@.>-<,;+:+8*9*:*:)<){=(x>(x>*>1{7.z7.z<1v;-w=/|A3{@2B7E:H=J?J@MBODQHSJ\Qh[tbgm~v|~}yqoiifgfeggde_~_Zw[PhPK^JBP?8D62:/.4*,/(+*%2&&5%(4%(2&(1'(/)+/+,.,-+++*+-*+-(,-(,/',/',/*+-.*+1++0+'.+"88,PUAiqYvc{hyh|il}mykzmrtq}p}p}s~v~x}x|x}zzwuqnje|bWkRN[GDF9?=1:8,45/45/45/560560560761761872872;83<94<94<94<73<73<41<41;30;3083072/61.61.5106216213122011/00./1-.2,04+.4+.4+.2,.2,,2,,2,,3/.3/,3/,3/,21,21,32-32.32032032032051051.61.61-;4.<5/=4-?6-A7.B8/E8/C9/D:1D:1E;2D:1C90B8/@5/@5/>3/>3/=2.=2.=20=20>31>31@51E31M02T,4X)3W(2R)1K,1B30:6-77+:6*B4)M2)X/)^/)f:1j;3s<7z=:<:<;;;::;7>8A8B9C:C:@9@7C2C1B0?/=.<.:-9-7+8+9+:+~=+x>*v?*x>*9-|/'8/>4w4+s5*}A6}C7E:GJ?KBMDQGWJ|aNzjQpYu]|biu|~{}zwzpzlxlwkumrlmgkd`rX[iRR[HHL=@@4;7,70&5*$6('5''3''1'&.)&+*(++)+-*',('+*)+*)+***,+),+),-)*,#$2*'50*86*BC5UZFfpWn}^teqbuexiwkshtiwkznxlwmxnys{u{w|wyuzwwtsomhd{_WkPN[GCC7>:195,560560671671782782872872983:94=:5>;6>;6>;6>95>95?74?74>63=52;63:5294194184184395484373243151240/6-06-.6-06-.4..4..4..4/,40-40-40-51.32-32-43.43.43/431542540841850940:5/=60>7/@7.A8/C90D:0G:1H;2F<3F<3F<3F<3E;2C90B71A60@51@51?40>3/>31?42@53?53@72C52I35P16T/6S.5P05J22C52=90<:-=:+C7)I6(Q3)W2)]2+d3,l50v64}77877766~75}:4}<6}>5?9@8?9A8B3C1B1@0=/;.:.9-9,9,:,<,|=,y>,x?,|=,5*2,LEXQA8|90F;K=yH:zJ<{M>|N?}OBQEUJ_LrkOosR|uXw]ybiszz|~{y~vpoppp{pwmskj~bfv\_hSV[GOM>GA3@6*=0';,'9+(6+'3+(/,',-'+.').().(+-(-,*/+*3)*4(*7'*7'(3($<3,E>4IG8QR@]bKgqVjyZn]k\l]pbqeodoerfumrjqitnxrzvyvyvvtwvurokjfc|^UlON\ECC7@91;4,671782782782893893983:94:94;:5>;6?<7?<7?<7@;7@;7B:7B:7A96@85=84=84<73<73<73<74<74<74;639529338308/09/.8/080.80.80.61.61-61-61-52-52-63.63.74/74/540540841952:63<94=84@93@70A8/C90D:0G:1H<0I=1I=1J=4J=4J=4I<3F<3D:1B8/A7.A81@70@72?61?61@72@72A83?74@85B86D97G96H96H96H94E80E8/E9-E9+G9,I9*K9+Q7*Z/&d/'n3-z6398;9;:=;A>@:=6<3:3<4=7@7A5B3@2?2=1<0;//|>/}>/=/9/1+<8lf~yZTC(+C&+E$+C&(F5-LC4VQ>[YD`bJgmQiwVj{Wl[gWfWl\oananbrfskojoirnwtyxxwuvssuvsrnlicb{[TmMM]CGH:E<5@707827828938938939:4:94:94;:5<;6?<7@=8@=8@=8A<8A<8C;8C;8C;8B:7?:6>95>95=84>95>95>95>95=85<73:51;30:0.:0.91.91.91/91.91.72.61-61-63.63.63.74/74/74/540651952;83<94?:4B;5B;3A8/B:/C9/E;/H<0I=1J>2J>2K>5K>5J=4J=4F<3E;2C90B8/B92B92A83@72@72A83B94A:4?82@93B;5D=7F=6G<6K<5N;4M6.N6,Q6+Q6+Q7*P9+P9)V6'f6*r6,~;3@9D@HDJGLFQJLDD;;07-7-91=4>5>7=6<5<5=4}=3z>3x@3vA3x@3z>3<3:37331(&=;|zhcG@K@xH:nMhV>lX@t[E`LhPysQwUt\l^__V\Q[T\ouzx̆|~}xvrtuuussr|nyju{amoWgbN_TBUE5R/(9/&7.'6/'81):/)=.+A,+F)+H(+K'+H)'TB4YQ9B?:D?;D?;E@8E>8D=7B;5B;5B;5B;5B:7B;5A:4A:4A83A83A83@72@64>71>71>71<71<71;60:5/85.85.74/74/961961961:70<71=82A:2B;1C:1D<1F<2J>2K?3L@2N@3N@5N@7N@7L?6K>5I<3H;2E;2E;2B90A8/@91?80?80?80@93@93<5/MD=M@:K:3T@9R62O0+a<6\3-`5.`4+^/'^/%f6,m=1q=0I=G;I?KAF>>7=6D;NDPEVJYKOBA5;0>69898655284?8|@6r>1rB4oA2q=0v:07243-1',HIbaEDWUyvVOFu:9:49:49:49:4:;5;<6>=8?>9>=8>=8A>9A>9B?:C@;D?;D?;FA=E@8E>8E>8E>8E>8D=5C<6C<4D;4C:1B92B92B92B92A83A83@93@93>71<71;60;6096/85.74/74/96196/96/:70<71>:1A:0B<0C;0E;/I=1J>0L@2L@2N@3N@3N@5N@7M?6J=4I<3H;2E;2E;2C:1B90@91@91@91@91A:4B92D93I81L/+V.,j76u99{;;ECD?H@IAG>IBNHPLOGD7B4B6C8>37-7-=0C5?0@0E3G6F6H:NELMHL@D9;98>:@8x>3o>0zI;LA?8,+).9DLWKNMM>=@?`\YQ@5TDyaIe[@^]?ihIslOvgJ~dKcNdX_[UZAN,E%D&H'I.N3N6UE8[O5cZ9gaAifEnrOz]zbt^r_p_p`q`udwdwdwfsixrzxyx~}zzromhhd`y[TmMNaERSAVPBUOC8938938939:4;<6<=7?>9@?:@?:@?:C@;C@;C@;C@;D?;D?;FA;FA;FA;E@:E@:E@:G@8F?7JA:I@9H?8G>5F=6E<3F<3E;1D:1D:1D:1D:1D;4D;4D;4C<4?80?80<71;60:5/:5/94.94.96/96/:5/;7.>7/@9/B90C;0E;1F<0I=1K?1M?2M@0NA1M@0P?5M?4L>3K=2I<3H;2E;1D:0C:1C:1A:0A:0?;2@<3@<3D;4UDI?LANBRJUROSLK@4B0@0?1;.7+8+=/E6>+7$:'>-A/C2D:02:BDLLRMRKLA>71{8/v6,x2*1-37=GGWM[FI53:931NKc]J?[J}cLj_CgdEtoOpQhJhNhYbbQZDQ7I1J2N/M*H2O0K1J5L4M2K3L7P@XC[F]IaNcQeUhVkSjRiOiNiNlPoSsVuha|[tUlYldrR]r-2^&'Y0,W:4Q?5B:-:8)>B1LN9VO3aV6e_?heDquTe~iwdxiuerdrcveyhzizjv~zypmg~b^wYTmMPcGSXDXUDYVG7827828939:4;<6=>8@?:A@;BA5G=3F<2E;1D:0D:0E;1E;2D;2E<3E<5E<5@91?80=82<71;60:5/:5/:5/96/96-;7.;7,?8.@:.C;0D0K?/M@0M@0M@/M@0O?2O>4L>3K=2J<3G:1E;1D:0D;2D;2B;1@<1@<3A=4B>5F<3S81[*&:?T`TeUfUcJO30:/>0A3F=IGBH>@B7F5B3@3?3>3B4D6G5B/<);(<(:(6&3(979=7>7<^@aCf@f?e?g?hCmErIsOuQuUvSqTnaxfvWb}15j0/X1*P8,G>/>A.;D/?G/PK._T8g`CokN||`rv}qzq|s|szozm}ouzsqh|c]tXSlNPdHRZCWYDYZH671671782893:;5<=7?>9@?:BA/K?1M@0M@0NA0O?/O?0O?2N=3N=3J<1I;0G;/D:0D:0D<1D<1B;1@<1A=2A?3B?6K=4\5.w32LS]iM_@Q6E&+1)7(:&<)@3D=>?;;?5B4@2?2@5C9H;J<>/?/=+;)9):,;/<1FADA>?797KCTLSMKJ?B5>274.7.1+:484@9[PUC{N9bIkP`F[FfTrdmhEK:D9C=8@?:@?:C@;DAGB>GD=GD=HC=ID>IE2I=1G=1G=1F<0F<0E;1E;1D;2C:1A:0A:0@91@91=82<71;60;60;7.;7.;7,<8-?9-A;/D0L?/M@0NA0NA0O?/O?/O?2N=3M<2L;1I;0G;/F90C9/C;0B<0B;1@<1@>2A?3B?6N;4m84FEY_WbCQ8F3;++1'8%:!9 ;&>.:2717,:-9-7,:1B8E;E:>2?0<,6'6)>0D;G=8-@6D?BB=A9>27.075GBSLNG=910/2671(A>GBOMWWNRDM:G5F2F.D1G7N8S8T8V9W;\>aAeCk;ej?m>n>o=m:jHr;a?dKnKnNmUoZnrajILt:8\6-P9+PC2UM:^QAreU|nʿ~m~k`t[WnRVjNS`FV`EX`H560560560560671893:94;:5=<7>=8A>9C@;DAHC?HC?GD=HE>ID>ID>JF=JF=MF2@@4P91r1/JKSV>D0603//1)1!9#=!;< =#;%6%6)8-6,4,81@:C<@6B7A4->-5+*&"%%+*1.4)*.+3,4,3,2,0-2+2%6&2&7,6.>7`UqeSVBM:WIf[d_RTCIFM@D??@<@8@7FAMLJN@K9H7H5H3E6G;M8P7R6R6U6X9];ak?m@qBtBuBuBtBpFmAaEeKjKkVt_z]tj~p~ow^aCAg6/hB7sUJye\}vŽ˺tqexb\sW[oS[jM\iK]gL561561561560561671872983<;6=<7@=8B?:DAHE>HE>HE2G=1E=2D;2C:1C:3A:2A:4@93?74<73<71>7/>7/<8/=90>:1A:2C<2D=3H@5I?3L@2MA1NA0P@0O@-O@-L?/L>1M=0L;1J91I81E80C90@9/>:/;;/<<0=>0>?1A?0S8-<7\[ZY86.*1+.%2#9&B*F,D'A&A&<#9#9*;0:07.<4CD;=<<@9>48,6.94HH@E;D:H:I8G;I?NAU?Vi>l>o>p>q@r@tAqCjMmSsJh@`Tsge]w_xh{p}qxgg^X{ZQ~wļ«zxl{hbu_`rXbpVboScmT21/320431651875984984984;:5<;6==5??7AA9CC9EE;EE;HH@HH>HHLC4J@4KA5MC9LB8F=4B90E<5C:5@93?74@85?75<74<42C:5B94A96>95?:7>:7?;8@<9B?:D@7G@6J@4L@0O@-O@+L?,G@.F?/I;0K81M53K65J88F;9B?:6904,=,<,=/C4F8>12&9+8*8+8-7-5.3/1-.,.-0,1,5*7):):(9&33 8'7'6(B5SINCSK\W]ZPR>C9??GAFCDAA?9<3;/?HH>HH9H?:F=8B;5D:8A96?74?74@85@85=85;62=4/=4/=52<74=96>:9=<:>=9B?:D?9G@6J@4M@0O@-P?+L@*B?,B?.F<0H:1J65I56F35@65@<9:=6;>5@@4E<-J9)^B4L>QB;-2#6&:'7$9%>*;%<(?+@-=,9*6(7)9):*9);+>.A1B/@.?,:(<+E6H9?18+6)7+7,9.;-8;1:-<-=.E5L?NEGC?>?B?F@JCJCLDPFTBS>S>XBaFhCi?i@jBpFvJzK{JzHtKpQs\z_{XwNqEkDlEiKg_pnukLI~t̲ų~/.,0/-10.21/43/540762761:94::2<<4>>6@@6BB8CC9DD:IF=IG;JH;LI8MJ7NL7NL7OL9KI:NKBTRS_^fihxmmlkkh`YiYQ\OGRH@KH>GG=EE93>:1=9083-94.;60<92=:3>;4?<5@<3E>4G?4I?3L@0O?0P?/P?-L?,<;&:=(?<+A;-B71A62>42;30=84B;5H94N2.Y,)l/.;=FE;02$1 9'<)7$8"<&;&=)A-A/>.<-:-->-<,?-8(>.L=G:6*2&9.6,6+8,:.:/8.6/3,0-.+.+1)2'6&8"7!8$5#9'>/=.6)9,A7<5>8EAKIJJCC?ACCCAD?B==4:.8*:*;+8)D8NEIE@@>ABIHPAG@ICOGTEU@U?XA_DfCiCkFpIwK{L|JzFxHwKtNtZ|aUvCdIkTv?\I`{||aC;|nճξ/.,/.,0/-10,21-32.54/650880991;;3==5??5AA7BB8CC9HEQPL^]bmlzzz{urke_{YSmTLdMEZG@PB;2?=1@<1?;/A;-F?/H?.K?/M@/O?0O?/P>0L?/@=*?>,@=.?;/?;2>93=:5:94<94D95M51V-+j)-288C>C7.7(:(?-?,9&8#;&:&<)>,@/>/=0=1>2?3=29.8*9+:,:,9*;,;-B4E9>31'2(9/5+4*6-7-7.6,3,1*0,.+/)0(2&4$6 5204$<.=/9.=2D:5-60;5D@MIKIC?=8@9A8>4Vdtӏd92lJ>ynХ10,10,0/+0/+10,21,43.54/77/880991;;3==3??5AA7DA8IE:LF:NH:PJ:RK9RM:SL:QK=OJDVTUfdqwxÏƎ{wpmid_[~UPnNJaKGXEBM?=B;7895296/85,85,671783891;;1>5L?6K>5F<3B92=82:946;47<59<5>:1H4-Y2-w78?D>E9<;0<+@.A/@-<);'>*8$:'<+=.<-;.<0=3?6>3:/7,7,8+8+8+7+A5C88.1&3)7-5+4+3)4-6,5,5+1*/*/,/*/)0'2#4!541/2"6)9-:0?6E=F>@7<5@9KDNGE>;1=1<0CBLIUJYFXCYC]@_BdElJsNzO|LyIvJwTT}JqImStVtNiD^F]Xk󝞎HFk.)kc͖ɿȾȿ65143.32.10+10+21,32-43.66.77/880::2<<2>>4@@6B@4JD8ME8OH8RK;TK:TM;SL*F@*G?*H@+IA,IB0IA4HB6HA9G@:K=?51;/<+?-?->,>*?+?-8%9(:+9-9,:.:0<4>5;4918.8.9/8.6,7-C9@70&,#7/<42*3,2(2+3*3+2+/*-*/*.)0)1(4$5"6 57#3#3$3&5)8,<1?6YQRJHAC;E1:*;(:*:):(:+>0A3A6<3<6A=EEGHIMLPBF@CCIKTNYJZF\F_A_BaEiJpNwOzNxLvQ{RyOvOtVy]{SoD^TlQddt`dMMjgΏX<94;8185052+41*41*52+63,74-85.96/;81=:1?<3A>5C?4JB7MC7PG8SJ;WK;UL=UK?SJCSJK]WcnlŚڟꢩ뙛啘ݔ֐ʉzyrqfc~XVkPN\IGRFCLCBJ??K==G;:@;9:<94?;/C=-E@,F@*FA+EB/EC4CC7BC;AC>@ACBLCANEEOCHNAIL>HI>GDCHAA=2L:.gF7OAI/>,>*?+@,@-?-<*8'8)9*9,8-8.91;5:4:3818192:2706/<5>5912(4*;2<33*1*1'1*2)1)/)-(,(-)/)1)3(5'6%7!7 9%8%6%4%4(7+8.7/NGXPZSQIG>D9@7>/<*<&<(:'9(;*>0A4D;@7@:FCIHHGGJIKFHBDDILSQZO]L]K`D^DaFfIlNuOxOxPwVxUvTvYx]{ZwQkI`WkUgM^^mKZTaTaXaefȃ~嫧@=6=:3:7074-52+52+52+63,74-74-96/;81=:1?<3@=4B>3JB7MC7RF8VJ:WK;XL?:6@<1A>/C@/CB0BC3BD7?D=>D@CVCIaLRhU\o\br`dobbjd`afXWaJDlG>SEXFJ7@+>+A.@/A-@-A.A/=+7&7(8+8+8-6-7/81;4727272829494836/A:8/3*8/=5=5915,2)0'0(0)/)-),(,(-)/)2)4)5'7&7$8#7"8%7$6&7)9+7+4*4+NGd\`YOFA7;29->)>'<&;%9&9*2D9A9E?KHLIGDEEHGIICDEHMSSZR\O^OaH^G`GdIiNrQxRyTzUuZw^}^|UpMgOiYn[mctM^TeO`UgL_R_^_vqלB>5A=4@<3>:1<8/:6-84+73*62)62)73*84+;60>93A<6E>6I@7MC7RF8UI9WJ:XK;ZLA[NHTIMXR`gd|~ʗ㞪쩫蟡ڙҍtrhe]ZXR~XQzYQvVOnMH_C?M?:@?;:B?8>>4@B5BE:?D=:CB>FH?LUDVnQfaristvxo^l[cWYWUVMM?@.9$:$<(=*?,@.@-?-=,;,6'6(6*7-7-8/91838495:693616183:3C<=670@7[Rlc]T?63)2)2*/)*&(%(&+(-+0,2+1'0#1"4$:(;&<(<)<*:,9+8,7-@881GAc^XQB<@;4*:&<$<&<&:(:+<0>2>4C;PJXROJ?:?:HDHGGEJKPTRWNVKXL\RfOfKeJfMlQsRvRvWvXuXu[w\xZsWnVkbuVg\m[lFXDXQeVefgieʏ網C?6B>3A=4?;2=90;7.:6-95,73*73*73*84+:5/=82@;5D=5H?6LB6QE7TH8VI8WJ9YK>ZMEUJNWQ_eby{ɔ⛦뢣㘘،ɀuqiec^`W`V]TVPtMIbFCTBAIAAC<<:AB=FEACD?A?@DBEOMRWVdchqu}}}{p`uYiVaQUHF@4;)<&='8$7%8&9(8'9(7(6(3%4(7-:2<3=5<5<5>9<7<7>9B=C=B[O@66,+#)#-)/-,+((0.4/616.3)2&2%6&:';'<(:(9*7)5)4(9/5-=6PJTQLHB?1(;(=&<';'9(8(:,:/>4B8OFWPRID=C;HCLHJFMLSRTWPVNVOZVfUhSiRkRmSqStRuMmUt\z_{\vUoRiReUfRbZhZhN^ScYiS^`_^W}٩EA6EA5C?4A=2?;0=9.<8-;7,84+84+73*84+:5/=82?:4C<4G>5JB7ND8RF6TG6WG7YIBZEJpW]csrz{vpcTnG\K\HP<<5.9*<'<%;';):);*<,<-<-<.6*8.<1?5A8>7<3:4714.3-93A;E?B<=5<44,4+7-2', 6*G:K>@64--),*,,,,*,*)/+2.5.4+1(1'3'7(:):(:);*:*8+8,4+<4:5<7ONYWEE3/;,<(;*:)9)8(8*8,=3A6JAUKRGG>D:G>KDICLISPSTPSMSNWXdZh[pZrVnRlQlQpGmPvZ}[{VrTkWk\mYhZham`k]gfnfm\_]W{OFmfݺIE9HD8FB6D@4B>3@<1?;0>:/:6-95,95,95,:5/<71>93@;5E>6I@7LD7OF5RE4UE5WG8WI>XMKXNW^Zqppԕ革ꗖ⌋ׂ}yumpgf`_ZYXQQuGGcA>Q=5DH8BT=C`@EnCJOU]dfxknoi`WxIg;U2HAPEM;<71?0@,:$6"5$5$5&7(8+;-/?0@3@36*LBJE50GFZ\IKA?2F9OBPDH7/=6.=6.=60>71@93?:4C>8EA8KC8NE6QD3RE2VF6VH;ZMGVMR[Whlk~Β㚦铕⊌نу{umkde_aY[RQsNHbWFY_CQmBLEMMTU][bZhRpRuTuPlJbBW8J.?8ECKGK>>>6F:H6?+>-=-<->/?0B4D7E:E9B7>5;26-5,3+3*1*4-7.90807/6.5,/&5+7+2#1"9)>-;)<-D7JAD?64*-*-/26755301,0*/,0-0+8191:1;2<0=0?0>17+WLaZ;6;:PQFHPQ<4:/8,9,:-<.;-;,:-<.A3H9I;D6@2>0F1E6E6F7E8F8G:G3;18/4,3*4+4,6-81<4=4<3905-5,7-.$;0=.1"-7&=):&9'8):/=9@@<>37,/,.+**)+(/,448899757473717-6*5(5&5(PEmcHA42CC>BVVA<>48.6+:-/=.9+<-?0A2A2@.=.<-C6D9H?PGRLOINLON^cagitnzduVjQiUoWvVtXp^pnywksXa`m`mbos}숊́|thyjskXON:_VGqgSM=RL4D=3B;3A:2@93A:4A96@;7A@;CC;IE9MG7OG2RF0UF1UH5WK?RHFXR^jg}Ēژ礧흤蛢晞⒚ۋ҆ʃ„ymczXiQ_MYIRAI=A=;>8C9H:I8F3C0@1TIG?;76488:;9874:/<.;.:.8+7*4'2&4*3*3(3)3*5,6.8/=3=2;18/7-6,4*3)3&3%4%6&=)>*9$2:&4%1'51<<=@7=37-1-.--/.439:;=9=2603011/1*2(1%3$1$=1j_TL95@?:=RSJHC=:36.8.;0<0=/;*?-@.?-;*;(;+<,>0>2D8LBPHNFLINLaeafhro{hxZkUjZrYs]tarjt}wy_dgtm|eulw좟Ĕ|hjUHQSK>PJF>DF@D8=65B;D8C8A5>29,6)2'2(3(4*5,5.4.4.4,B7=17,6,9-9-5)1%8(2 1!9(8'4"7%C07&8*6,5.3/53:9?>LKHFBB>=<=7:26,1+1)/,./.1+4*5)7(0!.dY]S@:DC;;MMRQHE;66/8.9/;-:+<,@-A.<)8%9&<)?.7)7+>1G:K@IAIBJEa_^`djnwku]iXe]m^sbtdolr~qsryyaqXfЮ]jPDR9QT?jbUXO@WP@WN?UN>TK2G?2H>2F@4GC:GE9JG8NI6RJ5UJ4UJ4VK9XNDULMZTbkh{~Ñט磤쥨ﭩ▟֦ζgzL]ER>M;G?<=EB:4D9F:1)JEJICE>B;?<=<;B;?7D;MAK>=06)9,7+6,5-2*/*/+2/5.A59+1$3&9+;-8&2245!4"4"4%5'5)0&2)5)6*4(3&3'4)2)3.5233/2-2-4.5-3+/+,/-5.9,7(4%-3"XHYN;3NI41HHOPJJC@;6808,9+<+<*;(9&;(<)=)=+<,8,;0=1?3?3@4@5A7japic_mjqqadgmpylzhxdobidjlnqoqoy{}Zlcwbp}u]rQJY:LR8snZ˷YPAXO@XO@VM>UL=TKLAC5:,9+7*7+6-4-2.3/5384>2;-6)5&5'5'5"49$9"9%:&<+<,8,4*3.5-7+7)6&4"4!4"2$2&0+.,,-,/-2.3+.,-0.2.4*5'8'9'?.*D5>1F>VPB?BAUVRRKHC>=59.9+8(;*;(:'<)>+?-@/>.:,;0=0>1?0?1B3C5i\mdb[kfolbakltxq~o|ir]fY`bfqpzxvwx~Rd[p]njkZtON_;SZ;us\ĸ\PB[OA[OAYM?XL>WK=VJD=?==A>CB;?9<686696;6HA;15+A5K>H:=/8)6)7)7,6.507195=93*5*6*6*5*7):*>,4!44!6"8)8)3(-%@;>8=3<.9)7$7"7#7%3$/&.'.*.-//./,)0+5-5,3&4%9&>*A/1 SE;0A;C?JITUUTSQOMJCC;<28+6&7&7%7&:'<*>-=,=,:,;/<.=/=.?0C4E7\Qg]aYlgpma`fgjqR^^khqem`geiqqxwtunuJ]Rh[m񜡣a`UoHOd=W`Aww]\PB\PB[OAZN@YM?YM?XL>XL>UI;TH:SG9RF8RF8RF8RF8PF:LE;KGE=F?F:>?@EDA<61>:ZYAB@C=@:=8997<8A8E;:.2(/9(8)9)8.:/8091;7>81+2*3,5,5-7.9.=/7(:)<+<,;.;0<695C@@<@7=19*9%:&;%<(7'1%1%1(3,1,/*2*5,7+7)5'7%;(>*;(<,^PF<3/.,@@WXusrojg^YPGA75(. 8'8(8&;)<,=-=,<-;.<..B3F7MA`Wa[pltr`a]a]dHTYegrgoelkpsvvvpsenDXKbXk뒖_zYQlCSh?\gEy|_\PB\PB[OA[OAZN@YM?YM?YM?WK=VJ@@?IE>82,C??=@1;-8'7%9'<)<):(>-:*>2C:/-::245653;6C>KCQISHTHUG?0?.<,=->-?.?/>0<.<.<.=,<,=.A3D6LAbXc]nlrr`c`e`gkvozkv`h_flqx{y|ms^jAWC]Uh懍g]YtI^uIhwPfǻ伺޺޼[OA[OA[OAZN@ZN@YM?YM?YM?XL>XL>WK=VJQI>QI>SK>UL;XM9XM7YL9XM;WK?ULGYSWe^nnjut~}ȍώԏՏӐӋʃ|u|ovioljlcyYvPoBd7V4L8H@EFBJCJEGGCJ=N>LCICCA>ID;44,I@LFBA?=;;<;@=E?G2A5A5A6G8A1;(9&<)=*<*8&:+7)0'C<2/?A/2*,1/5.81908.5*2&1#E5A2=.:*9)9+:,:,;/=0>/<.<+<,>/A2SGg^c_jinochjqoxq{t~mubkdnrzx~quipWfAY@[Qf~ykm]oZy`r֭ӦЧӫԮֱں[N>[N>[N>[N>ZM=ZM=ZM=ZM=YLUL=XLNAEFDA=HB:/7,OFB<=8641051>8E;F9D59(:(:*:'8%9&:':&9&:):,9+7+5+3+3-*+*--3/4173738588;8<9>9A9D7F6H5E+5-2124/6-8*;+=,5&8*;/=2>4=4>5A6J0/..46663-7.90:1;1;0:0;/L?F:@19*6)6(7*8*;-=/>0=/<+<+<.=0KAdZc^kiosinrzvfpoyryjslvwv}hocnRbB[ZM=ZM=ZM=ZM=ZM=YLVJ>XL>YN583/,*&/*:3C9C6>/;*;)<):';(<);'8%5$7%8)7*5*3*3)2*33588<4:-2(-(-+1-3)0&1)6,?*A 9/"0(.,10/1,3+5)6*6+90=6>7:4715092H=KYM=WMCWLHXNOZPX]Ub`Yia\rjfokspvq{u~ɊLj~yrrtl\HLB9A:C@@?:;<>DE><=<>=@ABICMANAL>>@9?6>3,7%:'<);(9%9&:':(:'9(6(2$."/%7.=582400-**&(%'%'%'&*!)".'7(>!;61'8#,#++---+(-)416264666512./,,/,92:191SK"+#F>.&.(<7E@:7/*.*51<7>4<.5)3&5*;.;08.bXZOC:6,:/8-3'6*0%2&2&4%6':*<.=1:0C;\Wppsvx|yq||wt}s{r~r}mxgs`nI\>\>[AVekzm}f~cjw|vzqyo|rvuwy§̹Կ̺ZM=ZM=ZM=ZM=ZM=ZM=ZM=ZM=XK;XK;XK;YL]P@[OC[NFYNJZPQ\SX_U^_Wfd\tibngqjxpyĊď~tnqujW{=A5+5+<3@8>8?:A==;;<;@>B@IAI@KAF<9=4<1;/:,:+A5JAG@A=6351@9C89+5#8';(=*=*;(;(:(9(9(6&2%2%5*8.80911&/%.%,&+'+),+-.*-%+$.'7$;7300.93<*1(,.002+.:>7=4:26/40325872-;582E?E?/+2."51?:E@=83-2,60:1:.9*5'5(9+<0<29/cYXN@84+91:06,9/5+4*4*5)6)5(6(6);0B9YTljqtx||v|yv~usp}kwdq_nI]>\>\CYehwozbu\x]ckppmp]l]h\g^k_qeyizktv|}ƷǿϼƷ\L<\L<\L<\L<\L<\L<\L<\L:A=E@GAH@E@B;6909+9*8(9*?3F9674;7C=OEH<3#9(:';)=+=,<+:)9)7)2#/#4*=3?6914+4&5&2%/$,$+%+(+(+-(+&/(6%:733%70;5A8C;D,626;3=6=8<7=6<2;19.6*6);/@6TMgeorz~||yxwsn}gv`p[mG^\FZ`a~evZiQhOmRtX{]}^x\qX`zM_PaUeYn`ug}j~mrtxyyz~ǹ˸ȶ[K;[K;[K;[K;[K;[K;[K;[K;ZJ:ZJ:ZJ:[K;[K;\L<\L<\L<]K=]K=]L<^M=^M;^O<^O<^O<^Q@^Q@]OB[OC\NE[NF\OI]OO^P_bTmdY{i^pg|t{{zxucMlFRA@A=E;H;G;E9A:@A0D:<731;9A?D?SLUJ:+9)7$7%;)=,=,9*8)4&2&2)9/>7>65./&6)6)4*1'.)-)*(**),','1)9&;GD=:<9:5807-6*4&3#5#6$8&;,9=9?9@8?5<2:.9-9,=1NHc_no|~yyyxtn}et^nVhE\8V^N>\O?^NA]OB^PE^OJbNYbQdcTqdZ}lexrwv}‰΂wlXwD_BTDPJPIHE>EBB@C@GBHDGCDA=?7@7=/:+:*9)8*;.?6FA=;BBAA;6JBXLK>@28(3#8(<-:*7)8+0%3)8/;4:5600+,'0,1-10312537486;-5,6.=0C-F)G+N3R9L3?@M_llzWfCS>P3D3A3>6<99834*/$2*.(72YT\ZXVA?HFB@<7706-8-9+7'5#8#9$:(=-;,6)7.=5NGEA501->9@:815120215283:2:/9.:.6*8+IB_Ynl}v}w~yxsk}dv^pSeF]8V=ZL]TRz_BWhC?EBEFBDAECFDEEAB:?4?3;-8(9(9)8*:-;3IE??=>782/A:ZPh[PCA35%6'9+9+7+8,0&6-;4;440/,-+--493;3=3=1>0=1=1>0A1B4K5N0N-O1X>_3HO\an_nWfP`DX8JAQ:G2:/22-8-;+:*:/2(JBkcLGPK;9;9LJ@<707--9)3':/D;GAC=722.;7:62.2-,-,,./3171:1<1>26)4)B:XRjh|}v}xzxqi{bt]oQcI`:X?[O_QNqX:Sf8]uEa|InSvY{]~`gll}m|o}ponllqqrroprtvtwï̫̾ZK8ZK8ZK8ZK8ZK8ZK8ZK8ZK8ZK8ZK8ZK8[L9[L9\M:\M:]L:^K<`J<^K<_L=^M;_N<^O<^O<^O:_P;`O;aP>aP>aP>aP@8>3>19+7':)<*<,=1?7=:9903/24294MElah[QCD>63;7UQF@918-:,9(9(=)?'<&;&=*7(3(=4LFGAE@963073510+1-,/+-./1/4/81;1>29.3(;2NHa^yzz|{xn~ew^pZlL`Ia9W=YM]JGhQ1Qd6\tDf~Nu[chjnsttr}pnmllnnoolknrttwƯν̻ʤ[J8ZK8[J8ZK8[J8ZK8[J8ZK8[J8ZK8[J8[L9\K9\M:]L:]L:^K<^K<^K<^M=^M=^O<^O<\O<`Q>aR=aR?bQ?bQ?aP>aO;bL>hOKgNRbP\cWkjfuv}|xzƄ}uzlmY[DL/I5R4=0?1;+8(<,?.@1A7C=7485..30:60'5)UGwj[PC7<0;07*6+:0708263320112364<%6#9"9"9!865629%B(G&J'M3\Ehbu`lWcQ]P]MZ@M2==F7;/./(5';(?&>%9'8+VJ;2?8412/C@WSHA916*6(5%5$:(<(:&7%9*4&1%?5RJIAHB;62.411/-+22,/+.+-++-*1*4,8,=12(7.IB\Xww}vj|_sXlTiD\D^6U:VLZHC^K-Mc5Uo?b}Jt\glnrvzwr~m|i}ggikmmlh~ijosrxũʵ¶Ş]K7\K7]K7\K7]K7\K7]K7\K7^L8]L8^L8]L8^L8]L8^L8]L:]J<]K=^L>\L<\L<[N=]P?^SA`SB_R?`P@bQAcRBdQBdNAdLBjMIhKMdPYf[lnkw{Ђy~sqjba^JW>Q:L?NCQ@KF9=4;0:,6&A0<,6(A5F==57285715.6-8*<*:'6%;0SLZOE98*>.B3:-3+GB//5:6=,7BM'3&2)2(2'"*'/'/&)+7 .&7-A#;Xr-D]l_iZcU\PWHM?@84>7A7?17&2!6#;'<)8-7/E?;7316454DCLHKED;:04)5(4)5*1=3_Ysqxh}_w[uUoLfEc:Y;[?Y]i@;VF-L^6YuBgMw]}cgjnonm~l}i|h}feflmlk~gfgimrv|z]K7]K7]K7]K7]K7]K7]K7]K7^L8^L8^L8^L8^L8^L8^L8^K:\K;^L>_M?^N>[N=[N=\Q?^RB_SC]QA]OB_OB`NDbPFcOHeNHiMJgNQeS_g_tnny~ʣxy|{vji`]aOZFRHSIVEP?J;E9?:<::=8?7>4/8(8);.;4JF016;6A.<@N'4$,%(),+,*+((((+,$'%(%,;D'4CAR&6jubjZaW]OSBC<8>68,D5H6>,/)((-%:6TPHG5445==WUGBG?A99/3)6,7/70=3915.2-4.83?9E=J@A86-0*0,210303021201/00.1-4-9-=13$aP@`P@]P?\O>[O?[RC[QE[QG\OG\OI_PMcQOfTTgUUgUUgV\h]nlisv|ˊԘנʪ}π䄆vsjegS\GQFOHREQAK=E7=7:99<7@7A4?0>->-<+:,B6H?;20):26/6.7,8,7(8&9&:*4-4.A9OCH:5%2#@2>5HD135;7@4@ES2?)0#&$'13-/''&%12)*8:+1)13=R^=K[g^fV\OTMREI:;74?96,?2B5=17-3),#' %/*EC::,,35AB^]?:C;A9=39/=4@8@;@<=;>;A?>>::?=IDB9<45,2+1-311202020201/00.1-4-9->24%8+;0[Tzw~rdy[tTqNmFg=_=\EbTgAHp;3SH2Qa<]xEfNrZu^t_xc{g{gyfyfycxbybya|bzczf{h{h{e{a{`}``jnstwuynolSeYAPM2A>^M9^M9^M9^M9^M9^M9^M9^M9^M9^M9^M9^M9^M9^M9^M9^M9^L8`N:aP<`Q>]P?ZN>YOCXPEXOH[QO_UTbXYeX_iYcl\fk^glaildqokrty~ʅڌᎇןӭijy{ށzwsrcgU\MTGPCM>G-=0F:RGH?5.1)9181;0=1;-6'6&8+5-2+=4NBK=:,8*B67.>:/0164<8BNZLU>E38$&/1,,22**/.::37,29@EMXcMW=CADBF>A9=8988978391:2A:NHVSNNC@7295KIMLQRYZRQYV51>6B9@7?5B9C<@;?@8=9=?C:?58>=MJ93603+3,4.30210102/201/0/.0-4-8-?36'5(9.VO|yzocwXqOlFh@c9\?^KdZh35g;0WO8WgCa{KjPsYt\u^wbyezfwdvawav`x`x`{azczfzgzfzbz`z]|]~_gntsuqtiidQcUDSL8G@^M;^M;^M;^M;^M;^M;^M;^M;^M;^M;^M;^M;^M;^M;^M;^M9]K5_M5`P9_P;\O>ZN@XOFXQKYPQ`W\g`hnfsshysg{sg}qh}ol}pqrwv}z҄响㝌ڠulnqvlvismllgi^`RWFM3=16*4'6*3,70=5E9F9B3A2>20&720/.1.47?PX]dZ_OS.103,-EE66,,-.>@2537bh=B*2-4&*;=@E6:379=7;/043;;GFRS`cilek^a@>E@^[hgopjjKK=;40>7D5<4:1415;-7,6.8,4,39b:_6\AaNeWap/+_?0[W>^lIe}MkSt\u_v_xcycxbu`u`u_v_w_x`{azbzd{e|d|`y^yZ{\}^agmpsr{nrjexe[k^RbU_N<_N<_N<_N<_N<_N<_N<_N<_N<_N<_N<_N<_N<_N<_N<_N:^L4_N4`N8^O:[N>YOEZSMZTT_Zahbprmzu{u{qzpvpqtrxt}wz~τڋޖܙ͛~yl[Q>MBQIWRWUSRKM>C4:9<9;;9=8@8B6A0?/9,A65+.$I?g\dZUI<26)3):0;06,3)6-1*71;29/>0F5B39+1(4-31-.*.17EJV[]b\a9<9<+,JK89//57()'+XZ>B9=6:#(+<>AE49,21705(.37KNaehncl`i`lbkLLNJ\ZVTMMHF423/ACJJ1.3,3,5,4-4/4/3/02/2.1-0../-2-7-=1;-1$7,C=yv|qhx_rRlDc9^6]6\FcN`IMe5+VD0[Y@^lIe|NkRt[w_x`{dzcv`s]r\s\t]v^w_{azbybzb|b{_x[xYzY{Z~_ekmsus|rupnlfwe_P=_P=_P=_P=_P=_P=_P=_P=^O<^O<^O<^O<^O<^O<^O<_N:aP6aP6aO9^O<[OA[RK\VV_Zakgvso}z~|}w{uxvsys}x{~ĄɍΔ͚ǠɭŦmfJE2A4@4B9HDNNJK?C=?;=<;=:@8@5>1=0:0?64,1'I?cVh[eWOB>24)7,905,2+600,4/7/7.>1C4>04%4*0+3/..-.1478BEMRY^FKQW37FJ80=*7.:;ECHAB1/4-4-5,4-3,4/4002/2.1-0../-2-7-:/>01%7,;5sqvi}at[pPjCb7`7a;_LfO[~86]=0NF1VX@ZeEcxMjRr[v^ya{dxas]pYpWqXqXt\u]y_x`x_y^z^y\xYxWyV{X_dhloqmxjqij~cbv]_P=_P=_P=_P=_P=_P=_P=_P=^O<^O<^O<^O<^O<^O<^O<_N:cQ9cQ9aP<]P@ZPG\TR_Zaa_mtryx~~yyyuwww|x}ĂąȸоѻЬoT\GG5>0G?WQWVNO@C=?<==;=:=5:19080<5:3=5OEXM]OeXcUL>:-8.914-2,60402-5.<3C7C4:-3%5,.&0-/,3154-.24BFX]W\ouDJHM@02:=HK9>7?=F7B-8>J]gmwjrcn]g^kao]nYe\]PIJG74/0540.95D?JDIA@86/4/7166'/0<2=+60:>E?A443.5.6-4,3*3,4/4101/2.1-0../-2-7-9.?20%6,61popcx\pXnOiBb9a`P@`P@_O?_O?_O?aQAbRB_O?]M=]M=aQAcSCbRB`Q>dS?aP>]P@^QI[QPZSZeapsqyxz|~}xzrslotwv{̀ʋƖäƳ̰ϬϧϣУ˜˜Ѩg^FzgueH?QNccKL?A89:::97561;6815.B;<3I?XKOAdVcTXIG9:/6-7/6/4/0-2,70=4<07)5(7,/$/&/)1-2040516479JNY]NS8=6+90>=HS_`igrepbmcn`o]gSSF@854111/.3194D=B:?7<4908193667<4;4;4<6;59331/3,5.7.5+3+2,2,201203/2.1//0.3.7.?58,6,/&;7XW{me|\rPhGeCe;d9`NlRd=?P, C;&CG.KM5Y_CZjEcxMqZxbx`t\rYqYlSmRnSoTrXtZu]u[tXtWvXwWvWvUuTtS{[{]z^u[mUb~MXrCSj>AW0?U/`P@`P@`P@_O?`P@aQAbRB`P@_O?`P@bRBcSCbRB`P@fVG_QF\OG^TSaZad`omkvwwy{}}x|qukplonquv|~ՉӘΨǸźαתۥޥݢۤأѠǛӼ}dŋw}mVJa[rpZ[KL?@=>>@;;6664=883?86.>3K@H;]Mo``QH:5)0&6-5-0)5195=7<38.5)4*5*7.5+2+0+0,2,4.5287>@JLW[^b\d]eaiS[NVQY_gjqflZ`NT4:,5*6-9'5!-'67CPZZdbldmencm[hQZEE<7646355302/62>9>7;4:3818295:69;7:7:797965312,3,6-7,6,2+1,1,201203/2.1//0.3.7.<3=28.1*74Z[s}fz^vWoOiFf?b^QA^QA^QA^QA_RB`SCaTD`SC_RB`SCaTDaTD`SC^PCbUM\QM[QRcYbkdtqmvuy{y{y~x|nsei`gjnru}}ׇݗ۩ػؿۧϡÜkpo`RG]Umiuu__JL@DAD>@8:66=:;6A:707,>3=/F8j\i[[MB62(4+6-2,52A>GC=62)1'2'0%4*1).)/)2,7/=4B9-(43DCVX^bZaS[Q[FQHSOY\fmvntY_>D.5-42<2>+9'46EKWISPWW_^fck`iRYBI977175<8;;955160:3;290907183:6<8999997988874402+6-7-8,6,2)0)0,10121302/1//0.3.6.90D9804./._blwbxWsPmLlCf:];_IfSgDJl;4O>,=<':?(ED/FH0Q\U'B\/E_2Ic6WJ:ZM=\O?^QA]P@^QA_RBaTD`SC`SC`SCaTDaTD`SC_RB\PDZOMZQVbXcjcsqmvuxzz|w|symrbi]daglrx{ʉߕ夡䶵۪ө¡vqrcbWi`rmut[]LNCG@D@?=;957282918080717396:7:7;9:7:8:6845.3+6,7-8,6,2)0)/+0/222312010/0.3.6.8/F<913.,,fjygtbyTqKkGj>c6Y=^QhXeBBgC7[N;GF1AC-JH3EE-LU6Sc>btLlUpXnRkPiKgIhJhKjMkPmToWpVtXsUqSoPjMgJeHdG`D]AWy=Rq8Mi6Lf6Ne7Of8Lf7Oi9Sm>UH8WJ:[N>\O?]P@]P@_RBaTD_RB`SCaTDaTD`SC_RB_RB^QIVMR_Xhnf{tpxtxwxzy{syjr`g[c_gjrv|ƀΓ䭮绽߹׶еƱy|qvksimeoi扄~sredWYMNDE@@:7;7B=E?<3=3B51#0"I;XKN@=/8*6*3*42UUkh]XD>;3;2804-2,1+0)0'/$/$0#9,4'3):5CAEGBG@HDOOZVaVa^igoYaBG:<5738283=9CHSV_6?4;6;ADJOIM;A135195<8<9;9:77370;2;1:09082736475:8;8:8:9;7956/3,7-8.9-7*3)1)0)1-323322011/0.3.6.7/C:701-13jpqzft]tPmCf=d9c8^EdZmV[wE>dJ=aYFTO;KI4PI6GE.GP3L\8ZlFf|NmSmRlMhJfHgHgIiLjOlSnVoUtVsUnRjLfKcHaF_FZBX|?St;Pn8Ok:Rl=Wn@ZqCUo?Vq>WqARE5UH8XK;ZM=[N>\O?^QA`SC`SCaTDaTDaTD`SC`SCbUEaVP^Vcje|yu}yzyxyvyswjrcj[c]ehpv~ǁшәݣ௳㻿þŹx{tyvquleleoga[`[smyu{|yrpccSTHGC?>:<6A;:1C:TJ>26)9,=.?/B1C5@17-2/LM_]WSD?:48170939292:19/9,8+8)(3"@2I>D@;:7;:@7AHRV_Yb^g`iU[AE@>?;ACGJLTQYT]V^4:/5/37:=A;?4812429586422020404.<4=4<3;2837343438898889997755/3,7-8,:+7*2(0(0(1,424332111/1.3.6.91<3710-@CnukubqRiHf;a4^6b>dNi\iGFjF:]L<]VCXQ>RJ7OG4ID.DJ.GU2Sc>^sHgMjOjKgGgFfGfHgJiNkRmUmUqUoQjNgKcH`E_F^G\E[~DWxAVr?Uo@YpB]rG^uG[sCYtAXs@NB2QE5UI9WK;XL\P@^RBaUEbVFbVFaUE_SCaUEfZJh]Yngwup|x{ywxvwpujoah^f_gempx}͉؏ؙ֪֡۴ߺɼĻqqqtpopfewhenj_Yd_ZTf`snzv{wwshfZWRNHB=6D=;4G=\R;0<07+6(>.D3B3A1A386>>CCB@=7817/7/:393:3;3>5A5E8G6-;%J8L==50+009>AJKTU`Ze]eYaLR>@4/7/;9@@CHDJBI?F5;26368<7914/2142095740.,*0,3.3,=5=4=4<3:59565655757576866542.1+7.9-:+7*4&1&1(1,425342211/1.3.6.;34+:520UXpxcnZiI`Ef8b/]5bBhLePYj5/^G7XK:UN;[P>VI8M@0JC0@F,AO.K[6Xj@bxGfJhIfFeDcBcEeHgLhOiRkSnRlPhNdJaH_F_H_H_H_H]~G]yF]wH`wKcxOczN]uC[vAZu@JC3MF6QH9TK.E6>-2"7'E7E?973.50;5=5<4=4;4925.4+5)8+<,?-S>G2<):-=2;57443KNMRPUTYY]VXMOD@5+7+7/52242618.64>3;5?9B4>+5(3/9-35759./*+0.515/<4=4=4=4;6:676664635253455411-0(8,:+:+8(4&3$3&4*5052423/2/2,4,6.=4/&>935bgoy[iNcC]Eh:e0]6aGhJ]CFR,#VI8SL:OH6[O?UI9F?-HF1>B'@J(IU1Sd:_rEe}IgJeHcCaBbCcEeHfMhPiQlPkMfJcIaG`F`H`I^G^F_}G`|Ia{Kd{Mf|Nf~N]xC]z@^{CDB6FD8JF;PG>RH>WI>]M>_O?`Q>aR?`SB_VGbYRgb_ojnso~wqzt|yywppgg`a\_`bfhopyz̄֍ߖ眙栞ݡף٤ڦإץԤӥѣ͢ɢȟÙ|rn}igld^`fZZkYUrWP}WNWORIZPXPZSkdyr|uqus_]PLEAZT712*6*7(7'7&9(;+<.?18.<2?4;05(3':/@590907.7+7):*?,A/=.@4E:G+?*?)?(?&?$<$<$8'9+<,9+5.545;984:3;4;5:595735435465454535/5,5)8,9*9(9&8&7%6%4&5-4/504.5,5+5*7,907/:6?BmwbsSjIcKj6[6_cNjIV^$"D, ?:'HE4PMC/?G/BH&EK%KS.S]8[kDavKd~NdJbF`Ba@cBeFhJlPmQlLiHgGfHfJeIcHaGdJdIbGc~GdJdHe~Ga}C[{<\=_B=?4?A6FC[K>]M=`O;`Q<^SA^VIc[Xhcinlysotpvptppmgfaa]^\\edkjtr}{φٍ易囖ٜ՝֞מ֝՜ԛўќ͜ʛǚēxtk|mdif]^f[YiZSoWM{UJVKVK\RYRXRfaqjvo~wusgdUSZU2,/%7)7&7%8&8';*;-=/9,9,:,:,9+9+8+8,;1908.8,9*9(:&9&6*80=5@8A9?7<4914->6H@OGQINFC;7*7%8$7)4,//+3)7(:+@*A)A&A#@!<=:: 9%;);-9197:;;94:5;4;5:595735235465464716/5,5)9*9*9(9&9&8%8%6%5+3+4,5*5*6(7)7*;14,54TYes[pGbIhAd;`3[;aMmLb8?S*$A5'69(;<,B@1DA0@?-=B.>G,=CKP'\b_?bB69.:<1??7DA:KB;OE/>/6(/":.8-7,8,:+:)9&7$5)6,8.:0=3@6A7B8:1@6E;FG=@67+6%6&7,4/03-5+9*<';'=%=#;!:77686$8*;2<6=8;::94:5;4;59585735236475565616/5,4(8)9)9'8%8%7$7$6%5'4)5*6(6(7(6)7+<21+88kr]nPi<[Hl7]>e5[>bVq?Qa#(L/);7+07'37&9<)@=*A<(@>)BB&?FXa4s~Tdw`hSa}LaG`C`?a@c@hEjJkMlNnMkHhHgGhKhKfLdJeKdJcFdGfHfGeFbBcDeEhH25*58-;<4A>7G@:KB;RE.>.8(/!6)5)4(6)9+<+=*;):-:/909/:1;1<3=3D9?8:8794:5;4;59585735447476665726/5,5*8*8(8(8&7&7$6$6$5%6(7'9(9(:(9):+:13.HKoyVjD_<_Ag3\8b>cMlOe0=J C1-11'.6'4=,=B.B@+B<$E>$HE$U\0p~Mr|mjW_{J]~E_Ca@bAfCkJlLmOmOoNlIiIhHiLiLhNgMfLdJdGeHgHhIfGdDgHiIlL-3'36+891<;6B=9G@:MD=QG=SI=SK>UNDZUQa^eigumklkjhb`XVPPQQXY`cfjorux|Ђֆه؊ً֋ϋ͉̊ЉшъщЌϋȍ~wmYjSZnVTc\RZaOZ_HeZDxUBLDTRSWRY^dejkluqunoh~v{~l`?28(;(='='<';':'8(7):/8.8,9+:+:*9)7(9+7+8,7+7*8*<,>-<0=0<2;/:08,7-5*@7@5=49.80;1:25,/%0)2025/8-9+;,<-?.?/@/@/A/?-?.@)9)8+70:6=8=774394:5;6:79585654448485676726/6,5*8*9(9(9&9&8&7&8&8%:&;'=(=(=*=,<.7/;8^eaqPi<[Ai4_4`1YKlYq>NZ%-C),:2/-0)08+7@/:B+<<"A<UH(`[5{Slwo[aK^F`DcBeDjGoNpPoSoSoNlIiIgGiLiLiOhNfJeIdHeIgIhHgGeDiIiKlN+1%.4*470893>:7B=:HA;KD18*4&8)<,:,:,;/;-:/9+5+5(6,;/>4?3?6>37.,#+%-*02391;0<0?0?0@1@1@0=/<-9,9*7/8IE4>1>0@/?.$?%@(@*=-;196U\^qGc?a:a7g3b8`FdNa@IS12A64@:<:46?56<7179+4="9CSZ.PqŊˎ̒Í}{egQ_E^@c@iDoJsPsSqUoSnNkJgGeEgJhKiNiNfKdIdIeHgJhIiHfEjLlNoQ&.!(0%-2+13.331764:95<;6GD=DD*;'7$4#B2OAN@B47)7)>/;+:*8(7'6'6(8*8+;.;/9-6*7,<1<271888=:A9B4A/<,;,:/;19384857563657376;9<69453376;9869796:7877767465:5:7:8995827/7+8+:*9+;*:*:(:*;(9":"=$>%?(?+<.81<89?48E26C41=:)>E&FU*bs?aˌɋËz{efPZ|@^?a>hCoJrOrRpTnRnNjIfFdDfIhKiNiNfKeJdGeFgHhGhGeDkLmOpR(0!'/"(-&).(.0-3317839:4==5?@8DE@JLKORYVXeZ\s]^}YX[Y^]eennwx؄⌌솇䂂܀ւӃ΀ȁǃ˄ΆЈӋҌϊŊ}xwozkegf]Xm[Qm[Mi\Lf^Kd_IeaHhaGo_FoP;UA]OaYYXQTS[\`heYPD<707/:1=/;+9(:&9(:)8)8*5,5,/%3)8,>/@/@-=*9'9)0"WJK?/#=12<07,8->4C5;687899:97877;=<<::8785747575979899::9;9<9<8<7;6:8:9:;9;5907,8+9)9+:):):(;*<)9#=':#49%D3?61,^eVgIb<\1X0Y6cBiYoFQo33N3,B?6>C<@78@-1L/3K2.A9&DJ(Zn=~_włʌ~nfRXvBY{?]>cAiDnImLlNkOlNiIfDcBcBfIhKfLdJgMhNgKfHeEfEjIkJqQrStU*0")/#).').(-/,130561782;<4>?7AD=HJGOPTSUaXYkZ\u\Z^]dbkjut~·ߋ鍍년 ؀~Ҁς̅Ɇȇˉ΋ό΍̎Ȋ|x{stknlb`e]Re`Me^Kf^Kh]Ki\Ij^Hk_Gn^Ew_G[CYFZLVPRSQXX_USLE>9606/909,9(8&8&8(8)7)6*4,5,0'5)9+=-A/@-<*9(8)<.REH<4(:-:,4&=,<+;*;*:)9)8)6(7*8,7,3)1'1(7.<5DG8>/9/:0=.;1<6?5:3622:8EBIFDC?>:7989796858598988788999:9;9<9<7;6:596888;8:59/7+8*:*:*;*;*<)<+<)9$?):%5:';/:2<=^gPdA[8W6[;`>dIe?L?>_:2G;/:>08>2F<:R>=N0.S8/VK5ciEx[p}Ɓ}xr^YuETp=\{B_@b@iCmHlKkLiMiMgGeCcBcDgJiLhNgMiOiMiKgGgFfElImLpQoRtU-1"-1#,/&,.)//-11/34/45-9;0<>1@B7EHAKMLQRWUUaVWi\Yt^]fdpnzx΍ߐꐎ튉燄߁|}ȀÆLjƊʌɌɌŌ|v{pujpndbi_Vc]M_aL_aKc^Jg\Jl[In\Ho]Gq]EwaIxX?S=VDXOUSOTMS><<784716/6.7+7(7&8$8&8'6)5*3,5,3(6(9)<+?-?-<+8(5'J=F:A584627272728596;8;877888:8;8<8<8<8;58475777:7:48/7,8+:+;+<+<+<)<+<)9&@*9$6$;+0'40PT[iJ`:U7V@]HfHdNa89e?6R@2DA09=,57)>6+K9/E-#R=,g]B_t{z{xm\uKHb5Nh8[xB_}?c@hDlGjIhJgLfKdDdCcDeFhKkNkOjNiOiOiMhJgHhHlKoMsVsWvY24&04&01)01+12-23.34.46+9;-;>-?A3DF9IJDMONRQWSS]XVd\Zoda~nlzwÌ֑㔑ꓐ뎋≅ق||~Ë}{vyn~rgmmaak^Vi[Pc\J]`K]aJc^Jh[JmZKqZJtZIv[FsWAxR;Q=YF[PTPFI>A2/5/51605.5+6)8)7$8$8&9'6)6*3,6-6)8'7&:(>+?-;+8)4'UI<18,B45%=+=+8(8'9(:)9)7)6(3'6*3)2)4,:3>7?9=:45596;5;2:397=<@UVbbmjidVQA<634/61717182859697:878898;9<8<8<8<7<5:686797<7<49/9,9*;*;)<)<+=);*<(:'@,8&8';-+"54`gTdG\-=@-@C.DG4IK>MNFQPNRRRVUSYX]a_lkius}njӕᔑ␍܋ӄā}||~zxsznzrfjm_^j[Ti[PjZKfZJb_Lb_Le^Li\Kn[Lr[Kw\K{ZG~UAR=RAVFRHG@88331-3/5/5.3,3)5(9(8$9$:&:'8)7*5,7-;+:)6%8';+=.;.7,90\T=55+A53$:(?+:):*:+:,;-:-8-7-3*1)1+71<7>:;77475;<8>7=7;7;797:::=:=7;2;/8*:*;*<)<*<(;););(=*8'9*8-/)@ChrM^H[DYH[O^T]TWXUdM?OL9LG4JE1FD-?B'=D#>H#KV.\g.==1==3==5;<4;=2;=/?B/@D-CG.FJ3KL:NOAQQIRRHYWJZZN_^\gerqn{yďяӍϊǃ~yzwyv{v|y|}}x|tzrvksrffm_\j\Sk[NlZLl[Kk[Ki]Mg^Mi]Mj]Mn]Ms^Mz]MZI`OVGN@J=@76.1+1+516/5.4-2)4'6&;(9$;$;&;':)9*7,9->,;(5#5#9)<.;/7-?7[TIA:0@36&3 <)9'7'7'7(7)7*7,7-<3:293<7>:=9854196<9::8:>@PPbcppheTP=61+40;7=:;7;5:294837373556669697;8<8>7=7=6:8<898:;:>:>7<28TXepK\I]J\M[QZVVZR`RPI7HM9NI5H@+;567>O%Lf6lTw\edfkt|mn}\Q`Cg{HiFlGmGjGfGbGcGhJlMoPnPlMiKjJjLsTsUsSrQrOsRwUzZvZu[sYRK;RK;RJ=RJ=RJ=RJ=RJ=RK;UNXQ?YR@[TD\UE\UEb[HaZHaYLbYRe][kaiqftuj{zn|pss|puj{mbre]jc`k`_g_\c_Z^^ZY^YUaZRbZOe[Og[Ki\Kk\Ik\Gm]Fm]Fj^HicMqfTqZJuOBWJ\PYLZLN=E4<,7(8-80411-6/7.7.7.7.7+6)7)8)8)9)9)9+9+8+;,;+>-9(1 2!9*H9=,2#PFJ@F<:7487::::776493=7F>B9:/4(1&5);/?3:0<3?7?:=;;9899:7:8:8:999797959540516576899:9:9;;>9;99=:A=B;A6?1:)<+=*<(:&:%8&8&A0<-/#/&LJmoloVZLNNOQMUOXO]RaTjSWZ/:M7FTa)~Poyxs~ahL\mCYdBT]BHP9?D0:=,@C2<@1:>0]sBgHpKoKlGjIiKgJlPmSoSlPmMkJmJmIqLqMrNrPtRvUyYz^ycmZbOWN?WN?WN?WN?WN?WN?WN?WN?XO@YPAYPA[RC\SD]TE^UF_VGd[JcZIcYMcYOf[Uj_]nbdpdhreltgpvirvirsfmm`gg[_bXY^[VZZRYVOWTKXTIXTH\VH^WGcZKcZIf[Ig\Hi]Gj^Fk_Gh`IcbMngTv\MSFVMVORJQEH9C0=,9)8,8062406.8.8.8.7-8-7,7+7+7+7+7+8+8+8+:,<.>.9(1 2 :)>.<.:-4*4);0E:OBQCOCF?@;<5;4=7=88633777879787797=9B:A7?4:,6'5&8)=-@1A4@6@7=8:777567:6:6<7:89879595:592:3:5;6;8;89999:;;;<=?=A;?6=2;-;+=*=+<);(:&8%:%9'8)5*<5QPee^aMMNLTMYP\Q^S^S_VfQ`_/Sg*^r3zOn|pbjHauBTe;JX7FP7?H59?158-:^tEgHqMpLnHkHkLhKmQnTmSmQkLkHlHmHpJpJpLsQuTxXxXx^mXbQYH]TE]TE]TE]TE]TE]TE]TE]TE[RC\SD]TE^UF_VG`WHaXIaXGe]Je]Hd[Jd[Le[Qf[Uh]Yh][i]]j^^k__k__i^\f[YbWS_VQZVMWTKUQHRNCQMBSOCWQCXRB^WG^WEaYFc[Fg\Hi^Hk`JhbLbaMngUy_PXN[UVQIEE@@7>1;/8+8+9,;/:/8.7-7-9.8-7,7,7+7+7+7+8+8+8+9+;,>0>.:(2 3:&>,>.?08+2(4*<0F9M?ND:643204297=<<<;<9<5:27265899<:@:8-:+6'4%5%8(<+=.D5C6B8=79464557969696977779595:3:3;4;6<6;8:999889:<<@>B=?9:17+7(;,<+<+;):(9&7%9&z6#y6%9,F=SOWTPOIFMHSLYP^SaWaW_VePsrFzVn{|[[oaXIaXIaXIaXIaXIaXIaXIaXI_VG`WH`WHaXIbYJcZKd[Ld[Je]Hf^Gf^Ig_Lg^Of\Pf\Rf\Sh]Wh]Wh]Wh^Ug]Te[QdZPc[N]YMZVJVRFRNBPL@PM>TN@UO?WQAYTA[VC]XDaZGd]Jf_LfaMdcQleUv\O[Qb\ZXFD<:<8;6:08-8):*?.?/9-7,8-9-8-8,8,7+7+8+8+8+8+8+9+;,?1>.9'3 38"=)@.?-:+7*5*7+:.7<380625587765615(7'6&7&7&9(:):*A1B4A7?8;5957687687878868694:4;492:2:4;7:8:89799<:@3B%:F.=F3;A3:=2:=4<=599-?@2<>39<1<@29B/?L2PbNK:NK:NK:PMTQ@VS@XWC[ZF]\H^]Kb`Qf^QmWJ[Ricc`MMBC;=8984709+=)C+B+;+7)8*:+9+9*9*8)8)8)8)9)9)9)9);,?1>0:(6"47 =&B-;*;,:,9-8.:0<0:49<4<3928384838256<494:7:9<76210(6(:(:(:(:(:(9&7&:+;/>3?7=8;896876666667484:3:3<3:2;2<5=7=:><=;>=@?1;=28;0;?18A.>K1Pb8770;.?+C*A(;*7(8)9*9*9*9*8)8)9)9)9)9)9)9);,?1=/<)9$65;"A*B.@/;,7*2(4+;0=85:3<6=8>:>;>:=9<587:9>=>=>962/0'9+>*>*>*=)<(:'8%6%7);0=3<5<7;8;787757585:4;4<4=4>5?7A:A;A>A?@=B??:@8=38-5(5'8(<*<(<)<(:&9'7%6$6%}:)t3!~9*OAYNRGOEVJYN[MZM[M\Q_T`WgW~xXy^r|ZU`B;E,/;%0;*0<.3=24<16<2?1:<17:/:>07@-=J0Oa;bxIkLuQuQtNqNrSpRrQsPrOpKnJpLsOvRyX{Zz]x]qWgO]EXB`NYISzCg^Og^Og^Og^Og^Og^Og^Og^Og^Og^Og^Oh_Ph_Ph_Ph_Pi`OjaPjbOjbOjbOi`Oi`OiaNiaNiaNh`Kh`Kh`Ih`IhaGhaGhaGf_Le^Kb[I\WDWR?PM:LI8IH6IH6GH6GJ9GK:HL;IM;A@CAEBC@A??1266:<=;;9714.4)<->+>+@,>+>(;':'7%7'8+8.7094=9>;:79595:4;4;4=4>4B7C9C9<3:/8+6(7'8):):(=)<*<):'9(7&6%}6$x3#x5%B2UEWKPCPDZLYMZN\Q\Q[T\U[VbUkbEV`=JS4=G,6?*2=,4>35?66=68?8=B;CF=EG/;9*78*=>0:<17:/:>06?,=J0N`:awHkLuQuQtNrOrSpPqOrNqMpLoKrNuTyX`~az]qUfL_G]E^IbPYISzCh_Ph_Ph_Ph_Ph_Ph_Ph_Ph_Pg^Oh_Ph_Ph_Ph_Ph_Pi`Qi`QmdUlcTjaRi`Qh_Pg^Og^Mh`MiaNiaLiaLiaLh`Ih`IhaGh`IgaKf_Le^Kb[H\WDUR?PMSQDSPAXLYSRODE::75;3>/=)8":)8'9(;*;*;*;*;*:):):):):):):);,;0:.<,>+9#37?'9#;)>0<18.7/<5?==B?DCEDC@?;7501./,51:6<6:28.8,:+=->+?,@-@-A+>*=*;*:(7(5)5+90?9C>=7;5;5<4<5=4>5@5D9D:C;A9?:;685937-8(5'6':)<*:)8&=*<+<*<)~:'|8%{6&{6&y1#8*G8SCPBL=RE_SWLYN[R]T]V\VYT^QaX;EM(6@8A&>G26BE*;:&78(=>09;069.:>06?,F7GK=IK=AE4KJ6\Q;aE/J9j]g`USFEA@A=>5=0=-4%5&6'7(7(8);,=.<-<-<-<-;,;,;,<-2(7.;/:)7"579"A-;+6)4*6/<7C?HEDEEHCC:661808.4+9/9.8.8-9,:+<+<+=+=*>+?,@-A,A-@-;*:(7(6)6+8-;3<4=6=6?8A7A9B6@6@5H=E;A8;25/3-1*2+9-;*9+:*:););+<+9'}8(|9(|9(|9({8'y6&x3$w- A4OCMAL@QEUJRG\R\RUMTLZUXSWTgZ]T5IQ*AK(BK,>H/7@+2=-4?14<1HPCZ^PW[JMO:DF.AA'==%:;)>?1;=2:=2;?14=*;H.PbF7>F7=E6@F8>E5>F1HL5MI0U?'Q:sbcX_ZUTGG@>A=?9:09+=,=.>-;-;+9+:*:,:+:,:+:,:+:,;.?5B:B7=/6#1125#6(;/A8E?IDJFKHCAEDB><39/=0?1=0?1>2>0>/=/>.@.?,=*;*<+=,?+>+>,>,@.=-:,8,8+8-:09/<2<2?5A7C9C9D9E8B6A4=3:06/5.4,7,:.=,;,;+:*;*<*<,~;*|;){9)y:)x9(w8'u6'w4$4'D7NCK?J>QDTIRGSJXOUOVP]XWRSOcT]W5Xc9_jBZfBIT66C)4@*0:<19<1<@25>+;H.PbMKD63?3A4A3A4;,:,8-7+6+6,7.:/;/<,;-;,:+;+;+<,};+z;*z;,w9*v8)u7(t6)v4&;1FEI0?C(=@#:<$89';<.8:/9<1=A36?,MK4>4>4>4?5?5?5>7?;B>D>F=FM@PDSHPGMGIEGBC?A=B=FBD??7=0>.C0G3I6F4E3C3B1A0}@.zA.|?-:,8,9+:,:,;-;+;+:+:)8)8*9,;/=/<0:/8.9/:.:.:,9+8*7)7(6)6*7+8-9/<0<.<-;,9*:*~9*}:*};+|:,z;,y;,w9*s8*q6(r7)u5)D8H=K?H:IB)=A(;='78(:;-79.9<1=A37@-NKB1=I1?G/LG1S>+g=-ZL_S>43+?9XUigdeRUJNNPIAF<@6>4@6D:G=G>JAJAJBJBKCKCKDKESRTTSRROSLSLULUNLHIFEBC@B@C@EBFDJFE@>7=2?2B1E3G4E3C3B3@0?1~?0z?/|>/:.9.9.9.;-;-;-;-9*9*9+:*:+;-<.;/;/9-9-:,9,8+8*8*8)8)8(8)9*:,:-;-:-:,9+8*}8)}7+|8+{9+z8,y9-x:-v8+q5*o5)q7+t9+H;IC-B47@-;H.L^8_uFiJtPtPtNrOsTpQnMmLpPwY|az`rXiQZA\EaIeMgMgKhJfLcPY{IRtBi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`QkbSkbSkbSkbSkbSkbSkbSkaUlbYlbYlbYlbVlbVlcRlcRldQldQldQlcRlcTlbVlbXlbXlbXocUnbRkbQlcRlcRkbQg`Pd]M^WGYSCSM?MJ;KH9GE6EB3?B/;H.?H-OC-a=-E:XRNJ,+:9=;SRpnvvehX^^_UQPFG@C:D=G>GAG?HCJBHDJCJFKDKGKGHHGIHHGGHDHDGBFBBAABBABBCBB@A>A?JGC?<6>3@3A0A0C3A2@1?1=1<0<1=1=1;1;1:3;1;1.9)9(:*:+;,;+;,:+:,9+7)~6({5){5){5)z6)x6*x8,w9,s8*p4)o5)r:-v<0M@KN)?O(J\2_rEk~QexKXj@M_7@Q-6E&7D*=F1=D4:>07;-8:,:;-68-8;0>B47@-9F,I[5[qBeFrNsOsMrOsTpQmLoOsUx\z`s[iQ`HYB^GeMgMfJeGgGhLaNXzHQsAi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`QkbSkbSkbSkbSkbSkbSkbSkbSlbXlbVlbVlcRlcRldOldOldMldMldMldOldQlcRlcTlbVlbVocUmaSkbSlcTmdUlcTi`Qf_Ob[K^WGXQARLB>@9C?C=C@D?CAD@ECDCADADDFGHIHJIIIGHACADBEBEAA@>=:=:FF=<83;2@4?1>0@1G]/AV-7H$1@!6B*=F5PK8MH5ID1DC.@F*DD([B,TG\X>A/3IN?E;>;FBFBB>>7D=D=D@EAEBECDEDF?C@DBEEEGGFFBC>?BD@C>A=>>>A?C@ECBB9850;4?6>3=/?2)=C5?>@=@=C?B?>:9370:0=2>3>2?2?3=2;393938192;0<.<.;-;/:.:.:.~:-~:-~:-~:-};/};/};/};/}90}90~80~8.7.7.7.~8,8,~8,}9,|8-{9-z8,x8,x8,x8.x8.w7-v8-v6,t6+s5*q5+m1'r6,n4)m3(o6+m4)q8-I=SHSJRGRHPHQJQKRLTMTK[NcQo_HYU:MV7O_;j~YbxQYoHUjCRg@Mb;IY5CR17D&4>#2:#6;'<>0@B5@@6<>358-39-4:.7:/9=/;?.=B,%Q?)kP=XGNBE=D?WVTTQQPONMMMLJKJTTHG=>=:B@EAB;>4D9E9F=G>FBDDAEAEBFCDCDDEDCFDFDFDEAD@B?A>A=A=A=C?E?C<>6:090:/<0<0A2~@3~>4<3:3918190;.<-;,;,;-:,:,:,9-9-9-9-~:/~:/~:/~:/}90}90}90}90}90}90|90|90|90z:0z:0y9/y9/y9/w9.w9.w8/w8/t8.s7-r6,r6,p6+p6+k1&q7,m4)l3(o6+l3(p7,~H>RISLQJPJQLPMQNSOOGSH[K{ePsiPhkLfqQgxT^tMXnGPf?La:K_:K\:GV7CP4>2;=04:03;05;16<0:A,>D*Q[9^mDkRpRpSqRsSsVx^|exakT`I]F]F\E`IaJcLeNdMbK`I^I]LRtBIk9i`Qi`Qi`QjaRjaRkbSkbSkbSjaRjaRjaRjaRjaRjaRjaRjaRkbSkbSkbSkbSkbSkbSkbSkbSlcTlcTlcTlcTlcTlcTlcTnbTqdTo_Pm]Pm_RqeYog\ldYhbVfbWpl`{xi~{jyizubpiVe`JTT(MB.S@/U8(]7*l=3n70u91~;5@:IBPJXPZR^YSNGEB?DBFCD@@:A;CG@GCFFEFDFCDCDCDCDDEEEECECDBDBD?C>C=C=C=C>E@E?B<>5:18-9,;-@2@1~>2=1:19181:0;.;,;,;,:,:,:.:.9-9-~:/~:/~:/~:/~:/~:/}90}90}90}90|90{8/{8/{8/{;1{;1z:0y;0x:/x:/x:/x:/t8.t8.s7-s7-r6,q5+o5*o5*j1&o6+m4)k2'l6*i3'm7+}G=PIPIPJQLRMSNUPVPWO[P~^OtbNoiQorUlwYfwUQeBK_:EY6DU3EV6GV9GT8ER8?I0*7;*:<.<>0;=/9;.6<25=26<26<0:0=@-=C)MW5Zi@f|MlNnQqRuUtWz`w`nWcL\E\E\EZC_HaJbKdMcLaJ_H]H[}JPr@Gi7i`Qi`Qi`QjaRjaRkbSkbSkbSjaRjaRjaRjaRjaRjaRjaRjaRkbSkbSkbSkbSkbSkbSkbSkbSlcTlcTlcTlcTlcTlcTlcTnbTrdWoaTm_Rk_SkaWlcZle[jf]jf]xtix~r}zg`cNOT>DG2FE1HC0F=,L<,VC4P9+R6*V4*Y5)\6+a9/e=1m=1KBSJUONKFDABDCFF@>A?B>E@ECFDEDEDDDCDCDDDDDEDEBFCFBEAD>E>DDA8;18,9+<-@0@1~?0=/:1:/9/:.:-;,;,:+:,:,9-9-9-9-~:/~:/~:/~:/~:/~:/}90|90}90{8/{8/{8/{8/x8.{;1y;0y;0y;0x:/x:/x:/v:/s7-s7-s7-r6,q5+o5*o5*m4)j1&o6+l3(h2&k5)h2&l6*|FG2:A/9=,9=.9=.8<-7;-7=36=56;46<2:<1;=/bxIjLnQsTwWxZ{ar[eN\EZC\E\EZC_H`IaJbKaJ`I^G]HY{HNp>Eg5haQhaQhaQibRibRjcSjcSjcSibRibRibRibRibRibRibRibRkbSkbSkbSkbSkbSkbSkbSkbSlcTlcTlcTlcTlcTlcTlcTlcTrfXth\sg[mcYjaXle]snhzwp~wz{kcfSOR?GJ7EH5BE2BE2EH5KL0A9,A7+@6*F4(S5*qB8PHPKIGGIEIBE@B@BBACBEAEADADADDDFDFDFDDEDEDDCFBFAF>E=E=F=E=F>A:C;E=B9>39-;..=-;/:-:-;.:-;-:,:,:,9+9-9-~:/~:/~:/~:/}:1}:1}:1}:1|91z:1|91y90y90x8/x8/v7.y:1y:1x90v:0v:0u9/u9/t:/r7/q6.q6.p5-o4,n3+n3+m4+j1(m7-j4*h2(j4*f2'j6+}D;NGNHQJTLUOWPYR[Q{YMv\OkZJ]UBYXDY^HOYA?K3:H/7E.4B+5A+8D.=I3CL7EN9BK6?H5.5<,4:,5<45<56;56;49;0:-;@)GP1Ra:`vGiKoRuVyYy[x`nW`IZ}C[~D^G^G]F`IaJbKbKaJ`I_H^IW|ILp@Bf6haQhaQhaQibRibRjcSjcSjcSibRibRibRibRibRibRibRibRkbSkbSkbSkbSkbSkbSkbSkbSlcTlcTlcTlcTlcTlcTlcTlcTkaUndZpf\lcZkd\rmg|ľrfcTPQ?FI8>E3;D1:F28E38E38C2:B34(P:/e?6EAPOX[QVCIFJEFFFEDEBDBD?CADDDFDFDFDCDCDCDCEAFAF@F=E/?/>.=-<-;-:-;.:,:,:,:,9+:+9-~8,~:/~:/~:/~:/}:1}:1}:1}:1z:1z:1y90y90x8/v7.v7.t8.w8/u9/u9/s9.t8.s9.r8-r8-q6.q6.p5-o4,n3+m4+l3*j4*h2(l6,i3)f2'h4)e1&i5*{B9MGMHPJTLVOXNYO|\Qs\Nk[L`WFVSBPSBJQ?@I64@,3<+2;*09(09(2;*5>-9B1G4:F2:C25@/3>-1<,3:33954954928919;.;>-;@*CL/O^7]sDiMpSwYyYwYqYfOZ}CX{A\E]F]F^G`I`I`I`I`I_H^G]JV{HJn@Ae7haQhaQhaQibRibRjcSjcSjcSibRibRibRibRibRibRibRibRkbSkbSkbSkbSkbSkbSkbSkbSlcTlcTlcTlcTlcTlcTlcTlbVj`VjaXkdZkg^upjμzym]_YIKL:@E1;D/>J6=H7=F5;C4;>5:;3983880==3C<2N71a84HH]_`dWZQSNOMKKJHGFDDABBCDDFDFCECEBDBBCBDCD@D?F?E.>-=,<,;,;,<-:,:,:,9+9-9-~8.}9.~:/~:/}:1}:1}:1}:1}:1}:1z:1y:1x90x90w8/t8.s7-r8-t8.s9.r8-q8-r8-p7,p7,p7,o6-o6-n5,n5,m4+l3*k2)i3)g1'k7,h4)e1&h4)b0%f4)zA8MGMHPJULXNYOxZOr\Nk^N^WGRPAKN=CJ:9B12:+08)17+17-06,/5+/5)08+2:+4<-9D4;F5=H7-.800621622717829;0:<.:?)?H+KY5[qChLqVw[wYsVgP^IUx@WzB[~F[~F[~F]H_J_J_J_J^I^I]H]JUvIJk@@a6haQhaQhaQibRibRjcSjcSjcSibRibRibRibRibRibRibRibRkbSkbSkbSkbSkbSkbSkbSkbSlcTlcTlcTlcTlcTlcTlcTlbVpg^ng_lgatqj}ub^\GKM7CH2AI2AI4@G5BD7AA7B=9C97?:69<5>?7B71J.+d66QRginm\\ZWVSQNLKHHCDBCCFDFDFCECEBDBBBBDCCBC?D>E>FD69A208+/7*6<247058157247025.06,08-19,6A3:E5=J9>K9-,6..400511606718:/:<.:?+WzB[~FY|DY|D\G_J_J^I^I^I]H]H]LStIHhA?]7icSicSicSicSicSicSicSicSicSicSicSicSicSicSicSjcSkbSkbSkbSlcTlcTmdUmdUmdUmdUmdUmdUmdUmdUmdUmdUldWibZgd]vsnʵƶibbFEH-DH/CG0FE1GD5F<3C60F42H:9>=9>?:B:7I75cGFjjœ譩ҋtn]XSPONJLFKFKEGIKDF;>>@GIDG:=@@@@A@B>C>BA9@9A9B8@5:.8*=0>/>.>-=,<+=*<,:+9-9-~8,~8.|8-|8-|8-|90|90|90|90z:1z:1z:1z:1y=5w<4w;3u:2t91q8/p7.p7.o6-m7-m7-l8-m7-l8-m7-m7-i2+m6/p92o81k4-g2*g2*h3+e0(i7.d2)]-#`0&_/%b2(s>6OJPKQJRJ}YMv_QfYITN>DE5>E5:C25@04&DR1WlChRs]w_rWkR[~DXyDTu@Tu@WxCZ{F[|GZ{F^JbNbN^J\}H_K`L^~MTsJFd@2I:3L95K<9?:7BA?MHE]RPyjgβſ쳪͂|c^VVRSHMADDEEEHHJKEF<><>AC????A@A@B>B=A<@9A<@;@9B:C;A6;18-=0>/>.>-=,<+<,<,:+9-9-~8,}9.|8-|8-|8-|90|90|90|90z:1{;2{;2z;2w<4u<3u:2s:1r90n8.o6-m7-m7-l8-l8-l8-l8-j8-l8-l8-k6.n70o81n91l7/i4,g2*e3*c1(d4*_/%^.$b2(^.$`0&p>5JERLXR~XOrVKdRDQJ:>?/:A16A05@03>04<14<15;17:379477577557246116//6./7,.9+1<.4A08E49H58G44E24B1.8/.5..3--2+23+46+8:-9=,7?(DQ3WlEhUt`wbpYgPY|DWxCTu@Tu@VwBYzEYzEYzE[|G_K_K\}H[|G^J^J^{MSnKF_A9R4icSicSicSicSicSicSicSicSicSicSicSicSicSicSicSicSkbSkbSkbSlcTlcTmdUmdUmdUmdUmdUmdUmdUmdUneVneVlfZed_y{xشğl`gEQX7DG,DC.JD4LD7KA8I>:C;9SJKia_wvecBEDIRVUTMKDACAFEEFDDCD=?>@@?@?B@B?B=A:@:@:B:E/>.=-~<,=-=-9-9-~:/}9.}9.|8-{8/{8/}:1}:1{;2{;2{;2{;2z;4x<4t;2q;1r90o9/n8.l8-l6,k7,l8-j8-j8-j8-j8-i9-j8-j8-n91m80m80m80m80i7.f4+c1(d2)a1']-#_0&c4*\-#_0&sD<}PJVP~YQpTI^J?OC7?<-46(2;*0;+1<.2=/4<14<15;17:379479668357257227007/08-.9+0;-2?.6C27E48G48G49F54>33:2/4-,2(/0(13(57*6:)6>'DQ5YmJkZwfwflZ_KWxCWuCTr@Tr@VtBXvDYwEYwEZxF]{I_}K]{I]{I_}K^|JZwKPgJAW@3I2icSicSicSicSicSicSicSicSicSicSicSicSicSicSicSicSjcSkbSkbSlcTlcTmdUmdUmdUmdUmdUmdUneVneVneVneVmg[jkfڴefmLMQ6FH0HJ5KI:HD9D@7OGDj`_収cd@?PKTMPHF@GBMJKH@?>>???>A?A?B?B=B=>9@:C=E?E>A9=5;2<1=0>/>.=/~<,=-=-9-9-~:/}9.}9.|8-{8/{8/~;2~;2|<3{;2{;2{;2z;4x<4r90o9/o9/m9.l8-k7,j6+h6+i7,i7,i7,h8,h8,h8,h8,h8,m;2l7/j5-i7.j8/j8/f4+a1'e5+a2(].$a2(b3)Y* a2(yNE\VvWRiNGWC:I<3@:.:;-8<.08)/:*3;.4@?A@C?C?C?C=?;A@9>5=3<1<2=1=0=1~<.=/=/~:/~:/~:/}9.|90{8/{8/{8/|<3|<3|<3{;2z;4y:3y:3w;3n70m80l7/l7/k6.h6-h6-h6-i7.h8.h8.g8.g8.g8.g8.h8.k92h6/f4-g5.i70h70e4-b1*c2+b3+_0(]1(]1(V*!b6-{ULtYRaNHN?8A7.=6,;9-9;.9<139-3;.5;/6<06<07:/58-47.69049238139/39/2:/19.19,.9+.9+/:,0;-3>.6C2:E5Qn>Qn>Qn>Qn>Qn>Sp@Sp@WtD[xH]zJ]zJ_|L_|LZwGRlECU?6D7(6)gdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSicSjcSkbSkbSlcTlcTmdUmdUmdUmdUmdUneVneVofWpgXpgXng]lnmz׹ĥregOMP;GK:FM=GOBKQG{{sžؓeSJ:TFWIF;@8KEC>C?B?C@C>C>D>B=B6<5/95,;8/8:/57,36+69.5;/7:/69.69.58-57,36+28,19,28.19,19.19,19,19,.9+.9+.9+/:,0;+3>.6A17B2ex\umtlf_RwKBh9KkVsCZwG]zJ^{K_|L_|LVsCNg@D=CUrDYvH[xJ]zL^{M\yKQn@G_;6B4+4/#)%gdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSicSjcSjcSjbUlbVlbVmcWmdUmdUmdUleUmfVngWogZnh\oh^mjekormtzη|ubb_NXZL]cWmwn|}̻pQDSFSHC:J@H@G>F>E=DG>G>C;>5:2:3>6=5=4=5=4<3;0;1;1~:/~:/~:1}90|90{8/{8/{8/z:1z:1x92w81v70u6/u6/q6.m80k90j8/j8/i9/i9/i9/h8.g7-f7-g7-f7-f7-f7-f7-f7-f5.j81m;4k:3j92j:0m>4oC8l@5oD;d<2c=2zVJdZyWMbLA>:13814927<54:0/5+25,9<336+25*24)03(13(25*46+47,.6),7)/7*-8*/7*/7*/7*/7*19,08+08-/7,/7,/7,08-08+7?09B14*00!''heVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVjdVjdVjdXldYlcZmeZmeXmfVg`NjeRnkXol]he\feasqrԶ|qtY_dMbkXr}lا`XD=NEMCF3<2:1919191~:1|91{80z7/z7/w7.v6-w7.w7.w8/w8/v7.u6-q5+n3+l7/i81i81h70h70g6/g6/g6/f5.g6/i70i81h70g6/e4-e3,h3-j5/m80k90j:0i;.i=0kA3gB2jI:dH:v_O~k\xjoRJ=79.4:04:039/39/39/28.28.17-17-36-06,25,/5+14+/5+/4-.5-/4-.5-/4-/4-/4-/4-05./4-/4-.3,.3,/4-/4-/6.1;23=26@58B79D67B45@03>-4?.DQ=WeN[kQPbHEX<@T8BW6Ic>Ke>Kf=Kf=JeOj?UpGYtK\vO]wP]wRWqNHb?;O6&1+&+.$),heVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVjcYkdZlc\md[meZmfVidQjhSmjWjk[gg_lll~ЯvkqUYaI_kUto~uKAM@K>L@K>E9=4?6E9F7J7L:J7F6C2C6E7C7B8A7>5<4:39193~92}:2z:1z:1y90x8/v7.v7.u6-v7.t8.t8.t8.r6,o5*m4+l7/i81j81h70i70h70g6/g6/e3,e3,g5.h6/j81j81j81k92k60l71k90k;1k;/j>1j@0iD2gH6kP=gRAufSuesrKL<69.39/39/39/28.28.28.17-17-17-17-06,06,/5+/5+/5+/4./4./4./4./4./4./4./4.05//4..3-.3-.3-.3-/4./6/.80/:21=34@66B66B66B45B16C1CP>P]IR`IIW@AO6BP7EU:Jb@Jd?Ke@Ke>Ic6I5&1-',0$)-heVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVjcYkdZlc\md[meZmfVmhUkiTmjWjk[kkcwwwۿʫyuy`kpZt{i؞L=RBL;@1G;YMUJ@4D7H:K=I;B7?3@7E;@9A9A8?6~>5}=4<4}=4z;4x<4w;3w;3u:2t91t91t91r90r90r90r90o9/n8.l6,k5+l7/j81l71j81k60i70i70h6/g5.g5.f5.g6/h70i81k:3k:3l;4j;3i:0h<1k?2jC4iD2fE2fI7lVAjYGujVm{mEF658-28.28.28.17-17-17-06,17-17-17-06,06,/5+/5+/5+/4./4./4./4./4./4./4./4./4./4..3--2,-2,.3-/4..5.+5-+6.-9//;12>24@46B47D38E3?L:ER>CQ:;I28F->L3DT9J_@Jb@LdBKc?Ia=G`9F_8G`9RkDXpL]uS^vVZqTPgK=T8.A.&1-',0%*.heVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVjcYkdZlc\md[meZmfVniVljUlkWlm]pqiؼǫ}ſñpP@O?XJM?E9G4e=1f>2hC3iE5fG3cG2cJ6hV@i\IskVozpq_9=,47,28.17-17-17-06,06,06,17-17-17-06,06,/5+/5+/5+.3-.3-.3-.3-.3-.3-.3-.3-.3-.3--2,-2,-2,-2,.3--4-*4,)4,*6,+7-.:.1=14@25A36C2:G5N4DX@7C;F?D=>;:7:8>;=;?<@=}@=xA6s>6r=5r=5r=5p>5o=4n>4m=3l<2k;1j;1i:0i:0j:0n72p62p62m61m61l71i70i70l;4k:3h91e90e90e90e:1d<2fB6cA5cC4dD5dG5dI6bI3_I2^L6eV?jbMrmWor[`L3:(28,28.17-17-17-06,06,06,17-17-17-06,06,/5+/5+/5+.3-.3-.3-.3-.3-.3-.3-.3--2,-2,,1+,1+,1+,1+-2,,3,,6.+5-*4+*4++5,.8-0;-2=/2=-5@/6A05A-1=)1=)5A-8F/=O5@T8FY=H\@J]?I^=K^>K`?TgG[pQcvZauZYkSJ]G6G4&4%$-*$),"'*heVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVjcYkdZlc\md[meZlfVjgTkjUlnYorasvmθκƶøͧkX[GWEL;D:DE?A>=::9;9=5o?5o?5o@6n?5m>4k<2h<1h<1h<1l<2o83q62p62p62m61l71j81i81h70g80e90e:1d<2e?4f@5dB6^B4aG8cL:dM;cM8`K6]K3]M4]Q9bX?mhRss[nv{eFO:4=*39-28.28.28.17-17-17-06,17-17-17-06,06,/5+/5+/5+-2,-2,-2,-2,-2,-2,-2,-2,-2,,1++0*+0*+0*+0*,1+,3,.5.,6.*4+*4+*4++5,-7,.9+-8*0;+4?/5@/4?.3?+3>-3@,7F/9K3@O8BT:GWJ=I>I@G@D>=::7=9>:?9A:xA:tD:pF:pE5j>5n=6o83r73p62p62n72l71j81i81d8/d90c;1d>3d@4cA5cA5_C5ZE4_NnlUtv^|kcmU2>(6B.3;.39/39/39/28.28.28.17-17-17-17-06,06,/5+/5+/5+-2,-2,-2,-2,-2,-2,-2,-2,,1+,1++0**/)*/)+0*,1++2+-4-+5-*4,*4,+5,+5,,6+-7,,6+/:,2=/6A17B27B15@04?.2?-4C.:G3=L5AO8DT:JX?L\BTbI\kTcqZ^mXUbPDRA2>0#/%&/,&,,$**heVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVjdVjdVjcYkdZlc\md[lfZlfVolYmlWjlWgkZflbr{x׭oYWDQ@O>OAOBK@C<<5>7?6?8A7{B7uD6qE8qE8p?8q?8s>8q?8q?8q?8q?8p?8sB;qB:o@8m>6l=5j>5m>6o>7o83q73o83m82m82i81h91f:1f;2d>3d@4bB5`C5]A3\@2WB1TG4[S>f^Gi^HbX?ZS9ZS7\W:ZV;XW;kmUsw^u}fUaI&28D03;.4:04:039/39/39/28.28.17-17-17-06,06,/5+/5+/5+-2,-2,-2,-2,-2,-2,-2,-2,,1++0*+0**/)*/)+0*+0*,1++2+)3+*4,+5-+5,,6--7.-7,,6+.8-2<16A39D69D47B46A10;+2?-5B09F22=/x=/t?/sB3tD6r=5r=7t=8s>8u@:u@:t?9q?8sA:q@9q@9q@9p?8n?7o>7o>7k92m82l:3l;4l;4h<3g<3c=2c?3^>1dG9cG9T=-N9(M8'@1WQ;PN7KI0OK2]Y>ieJeaDVU7XX<]`CosZzfdlU=I1-9#2>*4-1=)2>*9E/BN8IU?O[GVbN]hWYdTLWI/u@8s>8u>9u@:t?9o=6p>7sA:q?8p?8p?8n?7o>7m>6n=6m>6k<4l=5m>6k?6j?6gA6eA5bB5dG9[A2^G7^I8N=+F7$G8%>6!LL4GK2DG,DD*MM1\[?baC`aBYY=dgJsw^sy_X`I:D,/;%7C/6>16<26<26<25;15;15;15;15;15;15;14:04:039/39/39/27127127116016016005/05/.3-.3--2,-2,,1+,1++0*+0**1**1*)0))0))0)*1*+2*,3+.5--4,.5-07/4;39A6?F>BJ?;F8:E57B14?.3?+6B.)r>)s@+tD0vE4q?4n<3q<4tB9sA8o?5qA7xH>n>4m>4m>4k?4l=3j>3l=3j>3g?5gA6gA6gC7eC7cC6`C5^D5bK;UB1ZI7`S@RG3C;&E=(FA+AE,BH.AE*<@%?B%NN2_`AijKaaEnqTvzagmSJO94<%4=(=F38>28>48>48>47=37=37=36<28>48>47=37=37=36<26<26<25:449349349338238238227105/05//4..3--2,,1++0*+0*).().().().().(*/)+0*,1+160/4.,1+,1+/4.6;4=BK:4.8/-4--4-,3,gdUgdUheVheVheVheVifWifWifWifWifWifWifWifWifWifWkeWkeWlcZmd[md]mf\mg[jiWkmXimVjoYjs`hthm|wڻּҽz{R>tJ4uH3vI4zM8}P;yL7nA.e7'{M@sD:qB8sD:oC8g;0d8-g=1i?3i?3i?3g?3f>2f>2f>2e?2b@4bB5`C5_C5_C5[D4ZE4WD3XI6OB/\T?oiSc^HMK4IG0IK3>D*?H-@F*48>47=37=37=39?58>48>48>48>48>48>48>47<67<67<66;56;56;55:45:438238216005//4.-2,,1+,1++0*+0**/)*/)+0*,1+-2,-2,05/.3-+0*+0*-2.2718=9;B:@K=@M;@M;=J68E13@,1?(0>'4.:0,6..5.-4-gdUgdUgdUheVheVifWifWifWifWifWifWifWifWifWifWifWkeWldWlcZmd[md]mf\mg[jiWkmXinWiqZgs_drejytܿչйѾϴuawVCjI6lI6rM;uP>mF7iB3gB2jE5nI9nJ:oK;oK;eA1cB1cB1cB1cB1cB1bC1`C3]F6\G6\G6ZG6ZG6WH5TG4RG3PH3NH2fdM~~frrZVX@JL4GM3A.:>-;>39?59?58>48>47=37=37=38>48>48>48>48>48>48>48>49>89>89>88=78=78=77<67<66;55:449338227105//4./4.-2.-2.,1-+0,+0,,1--2.-2.,1-,1-,1-,1-.210513764;4;G9=L9@O<@O:8F71?2-9-,6--4,,3+fcTfcTgdUheVheVifWjgXjgXifWifWifWifWifWifWifWifWldWldWlcZmd[md]mf\mg[jiWkmXinWiqZgs_bpcgxrڽѵ˴˺ҿһsrb|]K}^LtUCaD2W:(Y<*[>,X=*`E2`E2`E2_F2`G3`G3`G3]H3\K7\M:\M:YL9XM9UM8RL6QL6NL5QQ9ikS|gmqXSY?FL2>G,48>48>48>47=37=38>48>48>48>49?59?5:?9:?9:?9:?99>89>89>88=78=78=77<66;55:4493382382/40.3/-2.,1-+0,+0,+0,+0,+0,,1--10.21/32/32/32-4-3?17F3=L7@O:?N7M:MJ9BC3=@5;A7;A7;A7:@6:@6:@69?58>48>48>49?59?5:@6:@6:@6;@:;@:;@::?9:?99>89>89>8:?9:?99>89>88=78=77<67<6495273162/40-2.,1-+/.+/.,0/,0/-10.21.23.23-12+1-+9*/@-6H2;M7=O7A6>A6>A6=@7=@79?59?59?5:@6:@6:B7:B7:B7;@9;@9;@::?8:?99>79>89>7;@:;@9;@:;@9:?9:?8:?9:?98?87=94;4382160/4..3/.3/.21.21,2.,2.+2++2*,4))6%$6)=!2F+8L1;O6;M5;M5;M58J29K3;M5H&DK*FM+EL*PV4PT3KN/HK,TT8bbFccIZZ@[Y@\ZA][B][B[Y@XV=US:SQ8HF1GD1DA0A?0@>1>>2??5>@5;>59?59?59A69A48C58C58C5:B79A69@88@58?79A69@8:B7:A9:B79@8:B7;B:E=8B:8B:7A88@56>14O<>P::L6@R8EW=FY=DX=@T;5H2+<),6+,3++2*ZgM[hN\hP]iQbjSckTglXhkXghVghVifWifWkeWlfXmeZmgYmgYkhYkg[kg\jf]jf[hfZefVhiWglVfo\erajwnz˹ʿNjlRM0SN0QK+QK+UO/UO/TO1TO1SO2SO2QP4QP4QM2PO3PN5NQ6MO7JP6HM6EM5HQ6EN1BK.?I'BI(FM+JP,KQ-NR/PT1VZ7^bA_bCY\?TWWU>XV=YW>XV=XW;WV:XT9QK3OI3LG4ID1DA2B@3A?3>@5<=59?59?59A67B48C57D37D3:B79A69A68@58@59A69A6:B7:B7:B7:B7:B7;C874>63=40>-3C)9M*BY/Ga1Op;Ln;Li=Fa>BY?F;J@?I>>I9?G8>F7>D8=B;>E>9C;6@74B19I/BV3Pg=XrB^J[}JXuIMhECZ@9O:6G54E2XR6:@6:@69A67B47B46C26C2;C8:B79A69A69A69A6:B7;C8;C8:B7:B7;C8;C8=E:>F;=G<=G?>H=>I9?G8>F7>D8=B;=D=9C;6@74B19I/DX5Ri?[uEZ{FWyFTqEIdA=T:2H3/@.->+6H2@R8L_CReGSgKOcG@W=6I30:/07/-4,YgMZhN\hP^jRblTemVinZjo[mn\lm[mk\mj[nhZnhZoi]oi[liZkhYjfZieZie\ieZig[ghXghVchRajWerao|s{ѿɶıþʾŸ̌oRL2TO2TM0UN1TN.UO/VQ3VQ3UQ4SO2ON2NM1PL1NM1NL3KN3LN6KQ7KP9JR:LU:IR5JS6OY7SZ9T[9]c?fnGcszpr{\\bFLP7KM5LK6KI4LJ5PK5TN8VP:WQ;VP:SN;QL9LI:IG:GE9CE:=>6:@6:@69A67B47B46C26C2;C8;C8:B79A69A6:B7;C8;C8;C8;C8;C8;C8F;=G<=G?=G<=H8>F7=E6=C7=B;:A:7A95?64B19I/BV3Ne;Uo?Tu@RtAPmAE`=9P6-C.+<*+<)1C-Makefile.depend include Makefile.depend netpbm-8.2/libtiff/Makefile.depend0100660000076400000000000000522707065504370016217 0ustar bryanhroottif_aux.o: tif_aux.c tiffiop.h port.h tiffconf.h tiffio.h tiff.h \ tif_dir.h tif_close.o: tif_close.c tiffiop.h port.h tiffconf.h tiffio.h tiff.h \ tif_dir.h tif_codec.o: tif_codec.c tiffiop.h port.h tiffconf.h tiffio.h tiff.h \ tif_dir.h tif_compress.o: tif_compress.c tiffiop.h port.h tiffconf.h tiffio.h \ tiff.h tif_dir.h tif_dir.o: tif_dir.c tiffiop.h port.h tiffconf.h tiffio.h tiff.h \ tif_dir.h tif_dirinfo.o: tif_dirinfo.c tiffiop.h port.h tiffconf.h tiffio.h \ tiff.h tif_dir.h tif_dirread.o: tif_dirread.c tiffiop.h port.h tiffconf.h tiffio.h \ tiff.h tif_dir.h tif_dirwrite.o: tif_dirwrite.c tiffiop.h port.h tiffconf.h tiffio.h \ tiff.h tif_dir.h tif_dumpmode.o: tif_dumpmode.c tiffiop.h port.h tiffconf.h tiffio.h \ tiff.h tif_dir.h tif_error.o: tif_error.c tiffiop.h port.h tiffconf.h tiffio.h tiff.h \ tif_dir.h tif_fax3.o: tif_fax3.c tiffiop.h port.h tiffconf.h tiffio.h tiff.h \ tif_dir.h tif_fax3.h t4.h tif_getimage.o: tif_getimage.c tiffiop.h port.h tiffconf.h tiffio.h \ tiff.h tif_dir.h tif_jpeg.o: tif_jpeg.c tiffiop.h port.h tiffconf.h tiffio.h tiff.h \ tif_dir.h tif_flush.o: tif_flush.c tiffiop.h port.h tiffconf.h tiffio.h tiff.h \ tif_dir.h tif_luv.o: tif_luv.c tiffiop.h port.h tiffconf.h tiffio.h tiff.h \ tif_dir.h uvcode.h tif_lzw.o: tif_lzw.c tiffiop.h port.h tiffconf.h tiffio.h tiff.h \ tif_dir.h tif_predict.h tif_next.o: tif_next.c tiffiop.h port.h tiffconf.h tiffio.h tiff.h \ tif_dir.h tif_open.o: tif_open.c tiffiop.h port.h tiffconf.h tiffio.h tiff.h \ tif_dir.h tif_packbits.o: tif_packbits.c tiffiop.h port.h tiffconf.h tiffio.h \ tiff.h tif_dir.h tif_pixarlog.o: tif_pixarlog.c tiffiop.h port.h tiffconf.h tiffio.h \ tiff.h tif_dir.h tif_predict.o: tif_predict.c tiffiop.h port.h tiffconf.h tiffio.h \ tiff.h tif_dir.h tif_predict.h tif_print.o: tif_print.c tiffiop.h port.h tiffconf.h tiffio.h tiff.h \ tif_dir.h tif_read.o: tif_read.c tiffiop.h port.h tiffconf.h tiffio.h tiff.h \ tif_dir.h tif_swab.o: tif_swab.c tiffiop.h port.h tiffconf.h tiffio.h tiff.h \ tif_dir.h tif_strip.o: tif_strip.c tiffiop.h port.h tiffconf.h tiffio.h tiff.h \ tif_dir.h tif_thunder.o: tif_thunder.c tiffiop.h port.h tiffconf.h tiffio.h \ tiff.h tif_dir.h tif_tile.o: tif_tile.c tiffiop.h port.h tiffconf.h tiffio.h tiff.h \ tif_dir.h tif_unix.o: tif_unix.c tiffiop.h port.h tiffconf.h tiffio.h tiff.h \ tif_dir.h tif_version.o: tif_version.c tiffiop.h port.h tiffconf.h tiffio.h \ tiff.h tif_dir.h version.h tif_warning.o: tif_warning.c tiffiop.h port.h tiffconf.h tiffio.h \ tiff.h tif_dir.h tif_write.o: tif_write.c tiffiop.h port.h tiffconf.h tiffio.h tiff.h \ tif_dir.h tif_zip.o: tif_zip.c tiffiop.h port.h tiffconf.h tiffio.h tiff.h \ tif_dir.h netpbm-8.2/libtiff/mkg3states.c0100660000076400000000000002224607020051061015533 0ustar bryanhroot/* "$Header: /cvsroot/osrs/libtiff/libtiff/mkg3states.c,v 1.2 1999/11/27 21:50:41 warmerda Exp $ */ /* * Copyright (c) 1991-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. */ /* Initialise fax decoder tables * Decoder support is derived, with permission, from the code * in Frank Cringle's viewfax program; * Copyright (C) 1990, 1995 Frank D. Cringle. */ #if defined(unix) || defined(__unix) #include "port.h" #else #include #include #include #endif #include "tif_fax3.h" #define streq(a,b) (strcmp(a,b) == 0) /* NB: can't use names in tif_fax3.h 'cuz they are declared const */ TIFFFaxTabEnt MainTable[128]; TIFFFaxTabEnt WhiteTable[4096]; TIFFFaxTabEnt BlackTable[8192]; struct proto { uint16 code; /* right justified, lsb-first, zero filled */ uint16 val; /* (pixel count)<<4 + code width */ }; static struct proto Pass[] = { { 0x0008, 4 }, { 0, 0 } }; static struct proto Horiz[] = { { 0x0004, 3 }, { 0, 0 } }; static struct proto V0[] = { { 0x0001, 1 }, { 0, 0 } }; static struct proto VR[] = { { 0x0006, (1<<4)+3 }, { 0x0030, (2<<4)+6 }, { 0x0060, (3<<4)+7 }, { 0, 0 } }; static struct proto VL[] = { { 0x0002, (1<<4)+3 }, { 0x0010, (2<<4)+6 }, { 0x0020, (3<<4)+7 }, { 0, 0 } }; static struct proto Ext[] = { { 0x0040, 7 }, { 0, 0 } }; static struct proto EOLV[] = { { 0x0000, 7 }, { 0, 0 } }; static struct proto MakeUpW[] = { { 0x001b, 1029 }, { 0x0009, 2053 }, { 0x003a, 3078 }, { 0x0076, 4103 }, { 0x006c, 5128 }, { 0x00ec, 6152 }, { 0x0026, 7176 }, { 0x00a6, 8200 }, { 0x0016, 9224 }, { 0x00e6, 10248 }, { 0x0066, 11273 }, { 0x0166, 12297 }, { 0x0096, 13321 }, { 0x0196, 14345 }, { 0x0056, 15369 }, { 0x0156, 16393 }, { 0x00d6, 17417 }, { 0x01d6, 18441 }, { 0x0036, 19465 }, { 0x0136, 20489 }, { 0x00b6, 21513 }, { 0x01b6, 22537 }, { 0x0032, 23561 }, { 0x0132, 24585 }, { 0x00b2, 25609 }, { 0x0006, 26630 }, { 0x01b2, 27657 }, { 0, 0 } }; static struct proto MakeUpB[] = { { 0x03c0, 1034 }, { 0x0130, 2060 }, { 0x0930, 3084 }, { 0x0da0, 4108 }, { 0x0cc0, 5132 }, { 0x02c0, 6156 }, { 0x0ac0, 7180 }, { 0x06c0, 8205 }, { 0x16c0, 9229 }, { 0x0a40, 10253 }, { 0x1a40, 11277 }, { 0x0640, 12301 }, { 0x1640, 13325 }, { 0x09c0, 14349 }, { 0x19c0, 15373 }, { 0x05c0, 16397 }, { 0x15c0, 17421 }, { 0x0dc0, 18445 }, { 0x1dc0, 19469 }, { 0x0940, 20493 }, { 0x1940, 21517 }, { 0x0540, 22541 }, { 0x1540, 23565 }, { 0x0b40, 24589 }, { 0x1b40, 25613 }, { 0x04c0, 26637 }, { 0x14c0, 27661 }, { 0, 0 } }; static struct proto MakeUp[] = { { 0x0080, 28683 }, { 0x0180, 29707 }, { 0x0580, 30731 }, { 0x0480, 31756 }, { 0x0c80, 32780 }, { 0x0280, 33804 }, { 0x0a80, 34828 }, { 0x0680, 35852 }, { 0x0e80, 36876 }, { 0x0380, 37900 }, { 0x0b80, 38924 }, { 0x0780, 39948 }, { 0x0f80, 40972 }, { 0, 0 } }; static struct proto TermW[] = { { 0x00ac, 8 }, { 0x0038, 22 }, { 0x000e, 36 }, { 0x0001, 52 }, { 0x000d, 68 }, { 0x0003, 84 }, { 0x0007, 100 }, { 0x000f, 116 }, { 0x0019, 133 }, { 0x0005, 149 }, { 0x001c, 165 }, { 0x0002, 181 }, { 0x0004, 198 }, { 0x0030, 214 }, { 0x000b, 230 }, { 0x002b, 246 }, { 0x0015, 262 }, { 0x0035, 278 }, { 0x0072, 295 }, { 0x0018, 311 }, { 0x0008, 327 }, { 0x0074, 343 }, { 0x0060, 359 }, { 0x0010, 375 }, { 0x000a, 391 }, { 0x006a, 407 }, { 0x0064, 423 }, { 0x0012, 439 }, { 0x000c, 455 }, { 0x0040, 472 }, { 0x00c0, 488 }, { 0x0058, 504 }, { 0x00d8, 520 }, { 0x0048, 536 }, { 0x00c8, 552 }, { 0x0028, 568 }, { 0x00a8, 584 }, { 0x0068, 600 }, { 0x00e8, 616 }, { 0x0014, 632 }, { 0x0094, 648 }, { 0x0054, 664 }, { 0x00d4, 680 }, { 0x0034, 696 }, { 0x00b4, 712 }, { 0x0020, 728 }, { 0x00a0, 744 }, { 0x0050, 760 }, { 0x00d0, 776 }, { 0x004a, 792 }, { 0x00ca, 808 }, { 0x002a, 824 }, { 0x00aa, 840 }, { 0x0024, 856 }, { 0x00a4, 872 }, { 0x001a, 888 }, { 0x009a, 904 }, { 0x005a, 920 }, { 0x00da, 936 }, { 0x0052, 952 }, { 0x00d2, 968 }, { 0x004c, 984 }, { 0x00cc, 1000 }, { 0x002c, 1016 }, { 0, 0 } }; static struct proto TermB[] = { { 0x03b0, 10 }, { 0x0002, 19 }, { 0x0003, 34 }, { 0x0001, 50 }, { 0x0006, 67 }, { 0x000c, 84 }, { 0x0004, 100 }, { 0x0018, 117 }, { 0x0028, 134 }, { 0x0008, 150 }, { 0x0010, 167 }, { 0x0050, 183 }, { 0x0070, 199 }, { 0x0020, 216 }, { 0x00e0, 232 }, { 0x0030, 249 }, { 0x03a0, 266 }, { 0x0060, 282 }, { 0x0040, 298 }, { 0x0730, 315 }, { 0x00b0, 331 }, { 0x01b0, 347 }, { 0x0760, 363 }, { 0x00a0, 379 }, { 0x0740, 395 }, { 0x00c0, 411 }, { 0x0530, 428 }, { 0x0d30, 444 }, { 0x0330, 460 }, { 0x0b30, 476 }, { 0x0160, 492 }, { 0x0960, 508 }, { 0x0560, 524 }, { 0x0d60, 540 }, { 0x04b0, 556 }, { 0x0cb0, 572 }, { 0x02b0, 588 }, { 0x0ab0, 604 }, { 0x06b0, 620 }, { 0x0eb0, 636 }, { 0x0360, 652 }, { 0x0b60, 668 }, { 0x05b0, 684 }, { 0x0db0, 700 }, { 0x02a0, 716 }, { 0x0aa0, 732 }, { 0x06a0, 748 }, { 0x0ea0, 764 }, { 0x0260, 780 }, { 0x0a60, 796 }, { 0x04a0, 812 }, { 0x0ca0, 828 }, { 0x0240, 844 }, { 0x0ec0, 860 }, { 0x01c0, 876 }, { 0x0e40, 892 }, { 0x0140, 908 }, { 0x01a0, 924 }, { 0x09a0, 940 }, { 0x0d40, 956 }, { 0x0340, 972 }, { 0x05a0, 988 }, { 0x0660, 1004 }, { 0x0e60, 1020 }, { 0, 0 } }; static struct proto EOLH[] = { { 0x0000, 11 }, { 0, 0 } }; static void FillTable(TIFFFaxTabEnt *T, int Size, struct proto *P, int State) { int limit = 1 << Size; while (P->val) { int width = P->val & 15; int param = P->val >> 4; int incr = 1 << width; int code; for (code = P->code; code < limit; code += incr) { TIFFFaxTabEnt *E = T+code; E->State = State; E->Width = width; E->Param = param; } P++; } } static char* storage_class = ""; static char* const_class = ""; static int packoutput = 1; static char* prebrace = ""; static char* postbrace = ""; void WriteTable(FILE* fd, const TIFFFaxTabEnt* T, int Size, const char* name) { int i; char* sep; fprintf(fd, "%s %s TIFFFaxTabEnt %s[%d] = {", storage_class, const_class, name, Size); if (packoutput) { sep = "\n"; for (i = 0; i < Size; i++) { fprintf(fd, "%s%s%d,%d,%d%s", sep, prebrace, T->State, T->Width, (int) T->Param, postbrace); if (((i+1) % 12) == 0) sep = ",\n"; else sep = ","; T++; } } else { sep = "\n "; for (i = 0; i < Size; i++) { fprintf(fd, "%s%s%3d,%3d,%4d%s", sep, prebrace, T->State, T->Width, (int) T->Param, postbrace); if (((i+1) % 6) == 0) sep = ",\n "; else sep = ","; T++; } } fprintf(fd, "\n};\n"); } /* initialise the huffman code tables */ int main(int argc, char* argv[]) { FILE* fd; char* outputfile; int c; extern int optind; extern char* optarg; while ((c = getopt(argc, argv, "c:s:bp")) != -1) switch (c) { case 'c': const_class = optarg; break; case 's': storage_class = optarg; break; case 'p': packoutput = 0; break; case 'b': prebrace = "{"; postbrace = "}"; break; case '?': fprintf(stderr, "usage: %s [-c const] [-s storage] [-p] [-b] file\n", argv[0]); return (-1); } outputfile = optind < argc ? argv[optind] : "g3states.h"; fd = fopen(outputfile, "w"); if (fd == NULL) { fprintf(stderr, "%s: %s: Cannot create output file.\n", argv[0], outputfile); return (-2); } FillTable(MainTable, 7, Pass, S_Pass); FillTable(MainTable, 7, Horiz, S_Horiz); FillTable(MainTable, 7, V0, S_V0); FillTable(MainTable, 7, VR, S_VR); FillTable(MainTable, 7, VL, S_VL); FillTable(MainTable, 7, Ext, S_Ext); FillTable(MainTable, 7, EOLV, S_EOL); FillTable(WhiteTable, 12, MakeUpW, S_MakeUpW); FillTable(WhiteTable, 12, MakeUp, S_MakeUp); FillTable(WhiteTable, 12, TermW, S_TermW); FillTable(WhiteTable, 12, EOLH, S_EOL); FillTable(BlackTable, 13, MakeUpB, S_MakeUpB); FillTable(BlackTable, 13, MakeUp, S_MakeUp); FillTable(BlackTable, 13, TermB, S_TermB); FillTable(BlackTable, 13, EOLH, S_EOL); fprintf(fd, "/* WARNING, this file was automatically generated by the\n"); fprintf(fd, " mkg3states program */\n"); fprintf(fd, "#include \"tiff.h\"\n"); fprintf(fd, "#include \"tif_fax3.h\"\n"); WriteTable(fd, MainTable, 128, "TIFFFaxMainTable"); WriteTable(fd, WhiteTable, 4096, "TIFFFaxWhiteTable"); WriteTable(fd, BlackTable, 8192, "TIFFFaxBlackTable"); fclose(fd); return (0); } netpbm-8.2/libtiff/mkspans.c0100660000076400000000000000431706747424643015152 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/mkspans.c,v 1.1.1.1 1999/07/27 21:50:27 mike Exp $ */ /* * Copyright (c) 1991-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. */ #include "tiffcomp.h" /* * Hack program to construct tables used to find * runs of zeros and ones in Group 3 Fax encoding. */ dumparray(name, runs) char *name; unsigned char runs[256]; { register int i; register char *sep; printf("static u_char %s[256] = {\n", name); sep = " "; for (i = 0; i < 256; i++) { printf("%s%d", sep, runs[i]); if (((i + 1) % 16) == 0) { printf(", /* 0x%02x - 0x%02x */\n", i-15, i); sep = " "; } else sep = ", "; } printf("\n};\n"); } main() { unsigned char runs[2][256]; memset(runs[0], 0, 256*sizeof (char)); memset(runs[1], 0, 256*sizeof (char)); { register int run, runlen, i; runlen = 1; for (run = 0x80; run != 0xff; run = (run>>1)|0x80) { for (i = run-1; i >= 0; i--) { runs[1][run|i] = runlen; runs[0][(~(run|i)) & 0xff] = runlen; } runlen++; } runs[1][0xff] = runs[0][0] = 8; } dumparray("bruns", runs[0]); dumparray("wruns", runs[1]); } netpbm-8.2/libtiff/mkversion0100770000076400000000000002315207060313626015255 0ustar bryanhrootELF44 (444ԀԀ   ̚̚/lib/ld-linux.so.1    ̚*@0 6DX"JȄ>UTax"i4p z؄g""XT! hFTTlibc.so.5_DYNAMIC_GLOBAL_OFFSET_TABLE__init_fini__fpu_controlfgets__setfpucw_IO_stderr_fprintfatexit__environstrchrexitfclosefopen_IO_stdout_environ__libc_init_etext_edata__bss_start_endX   ĚȚ K5%%h%h%h%h%h %h(%h0%Ěh8p%Țh@`YЃPSQ̀D$P;hqPn[t&̀&S=t Ѓ;u[Í6ÐUhȈhj&US]hSuShhj]]É'U WVSDž4Dž?UJ] 8-ƿRu*<N'3Uu-]RWjEPsu$RhXhvj&j EPƃtWkRwWjPuRhhjJW"j PTƃ tSj FP@ƃt?jEP,FAFuy u0A*v'Rhhjv~7hىPrǃu&PhۉhGj&XEPhW$h.WhTWXtW1[^_]ÐS=t Ѓ;u[Í6Ðusage: mkversion [-v version-file] [-a alpha-file] [outfile] rmkversion: %s: Could not open for reading. ../VERSION../dist/tiff.alpha-v-amkversion: No version information in %s. mkversion: No alpha information in %s. mkversion: Malformed alpha information in %s. wmkversion: %s: Could not open for writing. #define VERSION "LIBTIFF, Version %s\nCopyright (c) 1988-1996 Sam Leffler\nCopyright (c) 1991-1996 Silicon Graphics, Inc." ̚^n~΄ބ @  HԃW <d9dRt(l #Pkv#/;"K#Z'g(t)*+,-2345678!90^o+^LGLM3:'@#T$*D*D+D-D. $21D2D3D4D5D7)D90D:0@1@30$>== D>D? D@DF DG0DHCDIVDJ_DKdDLmDMuDNDODPDQDRDSDTDUDVDWDXDZD\ D]-D^4D_7D`=DaKDbaDcwDeDfDgDhDiDjDkDmDnDoDpDrDtDuDv(Dw/DyAD|PD}UD~dDoDzDDD=@=?@A4B@CI@D P@jdmkversion.cgcc2_compiled./usr/src/tiff-v3.5.4/libtiff/.././libtiff/mkversion.cint:t1=r1;-2147483648;2147483647;char:t2=r2;0;127;long int:t3=r1;-2147483648;2147483647;unsigned int:t4=r1;0;-1;long unsigned int:t5=r1;0;-1;long long int:t6=r1;01000000000000000000000;0777777777777777777777;long long unsigned int:t7=r1;0000000000000;01777777777777777777777;short int:t8=r1;-32768;32767;short unsigned int:t9=r1;0;65535;signed char:t10=r1;-128;127;unsigned char:t11=r1;0;255;float:t12=r1;4;0;double:t13=r1;8;0;long double:t14=r1;12;0;complex int:t15=s8real:1,0,32;imag:1,32,32;;complex float:t16=r16;4;0;complex double:t17=r17;8;0;complex long double:t18=r18;12;0;void:t19=19__long_double_t:t14_G_clock_t:t3_G_dev_t:t9_G_fpos_t:t3_G_gid_t:t9_G_ino_t:t5_G_mode_t:t9_G_nlink_t:t9_G_off_t:t3_G_pid_t:t1_G_ptrdiff_t:t1_G_sigset_t:t5_G_size_t:t4_G_time_t:t3_G_uid_t:t9_G_wchar_t:t3_G_ssize_t:t1_G_wint_t:t1_G_va_list:t20=*19_G_int8_t:t10_G_uint8_t:t11_G_int16_t:t8_G_uint16_t:t9_G_int32_t:t1_G_uint32_t:t4_G_int64_t:t6_G_uint64_t:t7_IO_lock_t:T21=s8ptr:20,0,32;field1:8,32,16;\field2:8,48,16;;_IO_marker:T22=s12_next:23=*22,0,32;_sbuf:24=*25=xs_IO_FILE:,32,32;\_pos:1,64,32;;_IO_FILE:T25=s80_flags:1,0,32;_IO_read_ptr:26=*2,32,32;\_IO_read_end:26,64,32;_IO_read_base:26,96,32;\_IO_write_base:26,128,32;_IO_write_ptr:26,160,32;\_IO_write_end:26,192,32;_IO_buf_base:26,224,32;\_IO_buf_end:26,256,32;_IO_save_base:26,288,32;_IO_backup_base:26,320,32;\_IO_save_end:26,352,32;_markers:23,384,32;_chain:24,416,32;\_fileno:1,448,32;_blksize:1,480,32;_offset:3,512,32;\_cur_column:9,544,16;_unused:2,560,8;_shortbuf:27=ar1;0;0;2,568,8;\_IO_lock:21,576,64;;_IO_FILE:t25size_t:t4FILE:t25fpos_t:t3wchar_t:t3div_t:t28=s8quot:1,0,32;rem:1,32,32;;ldiv_t:t29=s8quot:3,0,32;rem:3,32,32;;__compar_fn_t:t30=*31=f1comparison_fn_t:t30qelem:T32=s12q_forw:33=*32,0,32;q_back:33,32,32;\q_data:27,64,8;;usage:f19openFile:f34=*25filename:p26filename:r26fd:r34main:F1argc:p1argv:p35=*26argc:1argv:r35versionFile:26alphaFile:26version:36=ar1;0;127;2alpha:37=ar1;0;127;2cp:r26tp:r26GCC: (GNU) 2.7.2GCC: (GNU) 2.7.2GCC: (GNU) 2.7.201.0101.0101.01.symtab.strtab.shstrtab.interp.hash.dynsym.dynstr.rel.bss.rel.plt.init.plt.text.fini.rodata.data.ctors.dtors.got.dynamic.bss.stab.stabstr.comment.noteԀ#) p19 ԃB HK@@QHHV\bȈj p w ~ 0̚ TT T  Wg66<p P, $Ԁԃ@H  Ȉ   ̚T6   1 > I WdkP  ` p`  I    7 ̚XTX"T @hF! x""0p 7 F"LTX ]"d j4qTxȄ>؄gcrtstuff.cgcc2_compiled.__do_global_ctors_aux__CTOR_END__init_dummyforce_to_data__DTOR_END__crt0.Sdone__do_global_dtors_aux__DTOR_LIST__fini_dummy__CTOR_LIST__mkversion.cusageopenFile_DYNAMIC_etext_IO_stdout_fgets_IO_stderr___environ_init__libc_initenvironfprintf__fpu_control_start___crt_dummy__fopen__bss_startmainfclose_finiatexit_edata_GLOBAL_OFFSET_TABLE__endexit__setfpucwstrchrnetpbm-8.2/libtiff/mkversion.c0100660000076400000000000000736606765532157015522 0ustar bryanhroot/* "$Header: /cvsroot/osrs/libtiff/libtiff/mkversion.c,v 1.2 1999/09/08 19:09:35 warmerda Exp $ */ /* * Copyright (c) 1995-1997 Sam Leffler * Copyright (c) 1995-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * 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. */ /* * Generate a library version string for systems that * do not have a shell (by default this is done with * awk and echo from the Makefile). * * This was written by Peter Greenham for Acorn systems. * * Syntax: mkversion [-v version-file] [-a alpha-file] [] */ #include #include #include static void usage(void) { fprintf(stderr, "usage: mkversion [-v version-file] [-a alpha-file] [outfile]\n"); exit(-1); } static FILE* openFile(char* filename) { FILE* fd = fopen(filename, "r"); if (fd == NULL) { fprintf(stderr, "mkversion: %s: Could not open for reading.\n", filename); exit(-1); } return (fd); } int main(int argc, char* argv[]) { char* versionFile = "../VERSION"; char* alphaFile = "../dist/tiff.alpha"; char version[128]; char alpha[128]; FILE* fd; char* cp; argc--, argv++; while (argc > 0 && argv[0][0] == '-') { if (strcmp(argv[0], "-v") == 0) { if (argc < 1) usage(); argc--, argv++; versionFile = argv[0]; } else if (strcmp(argv[0], "-a") == 0) { if (argc < 1) usage(); argc--, argv++; alphaFile = argv[0]; } else usage(); argc--, argv++; } fd = openFile(versionFile); if (fgets(version, sizeof (version)-1, fd) == NULL) { fprintf(stderr, "mkversion: No version information in %s.\n", versionFile); exit(-1); } cp = strchr(version, '\n'); if (cp) *cp = '\0'; fclose(fd); fd = openFile(alphaFile); if (fgets(alpha, sizeof (alpha)-1, fd) == NULL) { fprintf(stderr, "mkversion: No alpha information in %s.\n", alphaFile); exit(-1); } fclose(fd); cp = strchr(alpha, ' '); /* skip to 3rd blank-separated field */ if (cp) cp = strchr(cp+1, ' '); if (cp) { /* append alpha to version */ char* tp; for (tp = strchr(version, '\0'), cp++; (*tp = *cp) != 0; tp++, cp++) ; if (tp[-1] == '\n') tp[-1] = '\0'; } else { fprintf(stderr, "mkversion: Malformed alpha information in %s.\n", alphaFile); exit(-1); } if (argc > 0) { fd = fopen(argv[0], "w"); if (fd == NULL) { fprintf(stderr, "mkversion: %s: Could not open for writing.\n", argv[0]); exit(-1); } } else fd = stdout; fprintf(fd, "#define VERSION \"LIBTIFF, Version %s\\n", version); fprintf(fd, "Copyright (c) 1988-1996 Sam Leffler\\n"); fprintf(fd, "Copyright (c) 1991-1996 Silicon Graphics, Inc.\"\n"); if (fd != stdout) fclose(fd); return (0); } netpbm-8.2/libtiff/port.h0100444000076400000000000000125207060313555014446 0ustar bryanhroot/* * Warning, this file was automatically created by the TIFF configure script * VERSION: v3.5.4 * DATE: Sat Mar 4 15:08:14 PST 2000 * TARGET: i686-unknown-linux * CCOMPILER: /usr/bin/gcc/gcc-2.7.2 */ #ifndef _PORT_ #define _PORT_ 1 #ifdef __cplusplus extern "C" { #endif #include #define HOST_FILLORDER FILLORDER_MSB2LSB #define HOST_BIGENDIAN 0 #define HAVE_MMAP 1 #include #include #include #include #include typedef double dblparam_t; #ifdef __STRICT_ANSI__ #define INLINE __inline__ #else #define INLINE inline #endif #define GLOBALDATA(TYPE,NAME) extern TYPE NAME #ifdef __cplusplus } #endif #endif netpbm-8.2/libtiff/t4.h0100660000076400000000000002603106747424643014027 0ustar bryanhroot/* $Id: t4.h,v 1.1.1.1 1999/07/27 21:50:27 mike Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #ifndef _T4_ #define _T4_ /* * CCITT T.4 1D Huffman runlength codes and * related definitions. Given the small sizes * of these tables it does not seem * worthwhile to make code & length 8 bits. */ typedef struct tableentry { unsigned short length; /* bit length of g3 code */ unsigned short code; /* g3 code */ short runlen; /* run length in bits */ } tableentry; #define EOL 0x001 /* EOL code value - 0000 0000 0000 1 */ /* status values returned instead of a run length */ #define G3CODE_EOL -1 /* NB: ACT_EOL - ACT_WRUNT */ #define G3CODE_INVALID -2 /* NB: ACT_INVALID - ACT_WRUNT */ #define G3CODE_EOF -3 /* end of input data */ #define G3CODE_INCOMP -4 /* incomplete run code */ /* * Note that these tables are ordered such that the * index into the table is known to be either the * run length, or (run length / 64) + a fixed offset. * * NB: The G3CODE_INVALID entries are only used * during state generation (see mkg3states.c). */ #ifdef G3CODES const tableentry TIFFFaxWhiteCodes[] = { { 8, 0x35, 0 }, /* 0011 0101 */ { 6, 0x7, 1 }, /* 0001 11 */ { 4, 0x7, 2 }, /* 0111 */ { 4, 0x8, 3 }, /* 1000 */ { 4, 0xB, 4 }, /* 1011 */ { 4, 0xC, 5 }, /* 1100 */ { 4, 0xE, 6 }, /* 1110 */ { 4, 0xF, 7 }, /* 1111 */ { 5, 0x13, 8 }, /* 1001 1 */ { 5, 0x14, 9 }, /* 1010 0 */ { 5, 0x7, 10 }, /* 0011 1 */ { 5, 0x8, 11 }, /* 0100 0 */ { 6, 0x8, 12 }, /* 0010 00 */ { 6, 0x3, 13 }, /* 0000 11 */ { 6, 0x34, 14 }, /* 1101 00 */ { 6, 0x35, 15 }, /* 1101 01 */ { 6, 0x2A, 16 }, /* 1010 10 */ { 6, 0x2B, 17 }, /* 1010 11 */ { 7, 0x27, 18 }, /* 0100 111 */ { 7, 0xC, 19 }, /* 0001 100 */ { 7, 0x8, 20 }, /* 0001 000 */ { 7, 0x17, 21 }, /* 0010 111 */ { 7, 0x3, 22 }, /* 0000 011 */ { 7, 0x4, 23 }, /* 0000 100 */ { 7, 0x28, 24 }, /* 0101 000 */ { 7, 0x2B, 25 }, /* 0101 011 */ { 7, 0x13, 26 }, /* 0010 011 */ { 7, 0x24, 27 }, /* 0100 100 */ { 7, 0x18, 28 }, /* 0011 000 */ { 8, 0x2, 29 }, /* 0000 0010 */ { 8, 0x3, 30 }, /* 0000 0011 */ { 8, 0x1A, 31 }, /* 0001 1010 */ { 8, 0x1B, 32 }, /* 0001 1011 */ { 8, 0x12, 33 }, /* 0001 0010 */ { 8, 0x13, 34 }, /* 0001 0011 */ { 8, 0x14, 35 }, /* 0001 0100 */ { 8, 0x15, 36 }, /* 0001 0101 */ { 8, 0x16, 37 }, /* 0001 0110 */ { 8, 0x17, 38 }, /* 0001 0111 */ { 8, 0x28, 39 }, /* 0010 1000 */ { 8, 0x29, 40 }, /* 0010 1001 */ { 8, 0x2A, 41 }, /* 0010 1010 */ { 8, 0x2B, 42 }, /* 0010 1011 */ { 8, 0x2C, 43 }, /* 0010 1100 */ { 8, 0x2D, 44 }, /* 0010 1101 */ { 8, 0x4, 45 }, /* 0000 0100 */ { 8, 0x5, 46 }, /* 0000 0101 */ { 8, 0xA, 47 }, /* 0000 1010 */ { 8, 0xB, 48 }, /* 0000 1011 */ { 8, 0x52, 49 }, /* 0101 0010 */ { 8, 0x53, 50 }, /* 0101 0011 */ { 8, 0x54, 51 }, /* 0101 0100 */ { 8, 0x55, 52 }, /* 0101 0101 */ { 8, 0x24, 53 }, /* 0010 0100 */ { 8, 0x25, 54 }, /* 0010 0101 */ { 8, 0x58, 55 }, /* 0101 1000 */ { 8, 0x59, 56 }, /* 0101 1001 */ { 8, 0x5A, 57 }, /* 0101 1010 */ { 8, 0x5B, 58 }, /* 0101 1011 */ { 8, 0x4A, 59 }, /* 0100 1010 */ { 8, 0x4B, 60 }, /* 0100 1011 */ { 8, 0x32, 61 }, /* 0011 0010 */ { 8, 0x33, 62 }, /* 0011 0011 */ { 8, 0x34, 63 }, /* 0011 0100 */ { 5, 0x1B, 64 }, /* 1101 1 */ { 5, 0x12, 128 }, /* 1001 0 */ { 6, 0x17, 192 }, /* 0101 11 */ { 7, 0x37, 256 }, /* 0110 111 */ { 8, 0x36, 320 }, /* 0011 0110 */ { 8, 0x37, 384 }, /* 0011 0111 */ { 8, 0x64, 448 }, /* 0110 0100 */ { 8, 0x65, 512 }, /* 0110 0101 */ { 8, 0x68, 576 }, /* 0110 1000 */ { 8, 0x67, 640 }, /* 0110 0111 */ { 9, 0xCC, 704 }, /* 0110 0110 0 */ { 9, 0xCD, 768 }, /* 0110 0110 1 */ { 9, 0xD2, 832 }, /* 0110 1001 0 */ { 9, 0xD3, 896 }, /* 0110 1001 1 */ { 9, 0xD4, 960 }, /* 0110 1010 0 */ { 9, 0xD5, 1024 }, /* 0110 1010 1 */ { 9, 0xD6, 1088 }, /* 0110 1011 0 */ { 9, 0xD7, 1152 }, /* 0110 1011 1 */ { 9, 0xD8, 1216 }, /* 0110 1100 0 */ { 9, 0xD9, 1280 }, /* 0110 1100 1 */ { 9, 0xDA, 1344 }, /* 0110 1101 0 */ { 9, 0xDB, 1408 }, /* 0110 1101 1 */ { 9, 0x98, 1472 }, /* 0100 1100 0 */ { 9, 0x99, 1536 }, /* 0100 1100 1 */ { 9, 0x9A, 1600 }, /* 0100 1101 0 */ { 6, 0x18, 1664 }, /* 0110 00 */ { 9, 0x9B, 1728 }, /* 0100 1101 1 */ { 11, 0x8, 1792 }, /* 0000 0001 000 */ { 11, 0xC, 1856 }, /* 0000 0001 100 */ { 11, 0xD, 1920 }, /* 0000 0001 101 */ { 12, 0x12, 1984 }, /* 0000 0001 0010 */ { 12, 0x13, 2048 }, /* 0000 0001 0011 */ { 12, 0x14, 2112 }, /* 0000 0001 0100 */ { 12, 0x15, 2176 }, /* 0000 0001 0101 */ { 12, 0x16, 2240 }, /* 0000 0001 0110 */ { 12, 0x17, 2304 }, /* 0000 0001 0111 */ { 12, 0x1C, 2368 }, /* 0000 0001 1100 */ { 12, 0x1D, 2432 }, /* 0000 0001 1101 */ { 12, 0x1E, 2496 }, /* 0000 0001 1110 */ { 12, 0x1F, 2560 }, /* 0000 0001 1111 */ { 12, 0x1, G3CODE_EOL }, /* 0000 0000 0001 */ { 9, 0x1, G3CODE_INVALID }, /* 0000 0000 1 */ { 10, 0x1, G3CODE_INVALID }, /* 0000 0000 01 */ { 11, 0x1, G3CODE_INVALID }, /* 0000 0000 001 */ { 12, 0x0, G3CODE_INVALID }, /* 0000 0000 0000 */ }; const tableentry TIFFFaxBlackCodes[] = { { 10, 0x37, 0 }, /* 0000 1101 11 */ { 3, 0x2, 1 }, /* 010 */ { 2, 0x3, 2 }, /* 11 */ { 2, 0x2, 3 }, /* 10 */ { 3, 0x3, 4 }, /* 011 */ { 4, 0x3, 5 }, /* 0011 */ { 4, 0x2, 6 }, /* 0010 */ { 5, 0x3, 7 }, /* 0001 1 */ { 6, 0x5, 8 }, /* 0001 01 */ { 6, 0x4, 9 }, /* 0001 00 */ { 7, 0x4, 10 }, /* 0000 100 */ { 7, 0x5, 11 }, /* 0000 101 */ { 7, 0x7, 12 }, /* 0000 111 */ { 8, 0x4, 13 }, /* 0000 0100 */ { 8, 0x7, 14 }, /* 0000 0111 */ { 9, 0x18, 15 }, /* 0000 1100 0 */ { 10, 0x17, 16 }, /* 0000 0101 11 */ { 10, 0x18, 17 }, /* 0000 0110 00 */ { 10, 0x8, 18 }, /* 0000 0010 00 */ { 11, 0x67, 19 }, /* 0000 1100 111 */ { 11, 0x68, 20 }, /* 0000 1101 000 */ { 11, 0x6C, 21 }, /* 0000 1101 100 */ { 11, 0x37, 22 }, /* 0000 0110 111 */ { 11, 0x28, 23 }, /* 0000 0101 000 */ { 11, 0x17, 24 }, /* 0000 0010 111 */ { 11, 0x18, 25 }, /* 0000 0011 000 */ { 12, 0xCA, 26 }, /* 0000 1100 1010 */ { 12, 0xCB, 27 }, /* 0000 1100 1011 */ { 12, 0xCC, 28 }, /* 0000 1100 1100 */ { 12, 0xCD, 29 }, /* 0000 1100 1101 */ { 12, 0x68, 30 }, /* 0000 0110 1000 */ { 12, 0x69, 31 }, /* 0000 0110 1001 */ { 12, 0x6A, 32 }, /* 0000 0110 1010 */ { 12, 0x6B, 33 }, /* 0000 0110 1011 */ { 12, 0xD2, 34 }, /* 0000 1101 0010 */ { 12, 0xD3, 35 }, /* 0000 1101 0011 */ { 12, 0xD4, 36 }, /* 0000 1101 0100 */ { 12, 0xD5, 37 }, /* 0000 1101 0101 */ { 12, 0xD6, 38 }, /* 0000 1101 0110 */ { 12, 0xD7, 39 }, /* 0000 1101 0111 */ { 12, 0x6C, 40 }, /* 0000 0110 1100 */ { 12, 0x6D, 41 }, /* 0000 0110 1101 */ { 12, 0xDA, 42 }, /* 0000 1101 1010 */ { 12, 0xDB, 43 }, /* 0000 1101 1011 */ { 12, 0x54, 44 }, /* 0000 0101 0100 */ { 12, 0x55, 45 }, /* 0000 0101 0101 */ { 12, 0x56, 46 }, /* 0000 0101 0110 */ { 12, 0x57, 47 }, /* 0000 0101 0111 */ { 12, 0x64, 48 }, /* 0000 0110 0100 */ { 12, 0x65, 49 }, /* 0000 0110 0101 */ { 12, 0x52, 50 }, /* 0000 0101 0010 */ { 12, 0x53, 51 }, /* 0000 0101 0011 */ { 12, 0x24, 52 }, /* 0000 0010 0100 */ { 12, 0x37, 53 }, /* 0000 0011 0111 */ { 12, 0x38, 54 }, /* 0000 0011 1000 */ { 12, 0x27, 55 }, /* 0000 0010 0111 */ { 12, 0x28, 56 }, /* 0000 0010 1000 */ { 12, 0x58, 57 }, /* 0000 0101 1000 */ { 12, 0x59, 58 }, /* 0000 0101 1001 */ { 12, 0x2B, 59 }, /* 0000 0010 1011 */ { 12, 0x2C, 60 }, /* 0000 0010 1100 */ { 12, 0x5A, 61 }, /* 0000 0101 1010 */ { 12, 0x66, 62 }, /* 0000 0110 0110 */ { 12, 0x67, 63 }, /* 0000 0110 0111 */ { 10, 0xF, 64 }, /* 0000 0011 11 */ { 12, 0xC8, 128 }, /* 0000 1100 1000 */ { 12, 0xC9, 192 }, /* 0000 1100 1001 */ { 12, 0x5B, 256 }, /* 0000 0101 1011 */ { 12, 0x33, 320 }, /* 0000 0011 0011 */ { 12, 0x34, 384 }, /* 0000 0011 0100 */ { 12, 0x35, 448 }, /* 0000 0011 0101 */ { 13, 0x6C, 512 }, /* 0000 0011 0110 0 */ { 13, 0x6D, 576 }, /* 0000 0011 0110 1 */ { 13, 0x4A, 640 }, /* 0000 0010 0101 0 */ { 13, 0x4B, 704 }, /* 0000 0010 0101 1 */ { 13, 0x4C, 768 }, /* 0000 0010 0110 0 */ { 13, 0x4D, 832 }, /* 0000 0010 0110 1 */ { 13, 0x72, 896 }, /* 0000 0011 1001 0 */ { 13, 0x73, 960 }, /* 0000 0011 1001 1 */ { 13, 0x74, 1024 }, /* 0000 0011 1010 0 */ { 13, 0x75, 1088 }, /* 0000 0011 1010 1 */ { 13, 0x76, 1152 }, /* 0000 0011 1011 0 */ { 13, 0x77, 1216 }, /* 0000 0011 1011 1 */ { 13, 0x52, 1280 }, /* 0000 0010 1001 0 */ { 13, 0x53, 1344 }, /* 0000 0010 1001 1 */ { 13, 0x54, 1408 }, /* 0000 0010 1010 0 */ { 13, 0x55, 1472 }, /* 0000 0010 1010 1 */ { 13, 0x5A, 1536 }, /* 0000 0010 1101 0 */ { 13, 0x5B, 1600 }, /* 0000 0010 1101 1 */ { 13, 0x64, 1664 }, /* 0000 0011 0010 0 */ { 13, 0x65, 1728 }, /* 0000 0011 0010 1 */ { 11, 0x8, 1792 }, /* 0000 0001 000 */ { 11, 0xC, 1856 }, /* 0000 0001 100 */ { 11, 0xD, 1920 }, /* 0000 0001 101 */ { 12, 0x12, 1984 }, /* 0000 0001 0010 */ { 12, 0x13, 2048 }, /* 0000 0001 0011 */ { 12, 0x14, 2112 }, /* 0000 0001 0100 */ { 12, 0x15, 2176 }, /* 0000 0001 0101 */ { 12, 0x16, 2240 }, /* 0000 0001 0110 */ { 12, 0x17, 2304 }, /* 0000 0001 0111 */ { 12, 0x1C, 2368 }, /* 0000 0001 1100 */ { 12, 0x1D, 2432 }, /* 0000 0001 1101 */ { 12, 0x1E, 2496 }, /* 0000 0001 1110 */ { 12, 0x1F, 2560 }, /* 0000 0001 1111 */ { 12, 0x1, G3CODE_EOL }, /* 0000 0000 0001 */ { 9, 0x1, G3CODE_INVALID }, /* 0000 0000 1 */ { 10, 0x1, G3CODE_INVALID }, /* 0000 0000 01 */ { 11, 0x1, G3CODE_INVALID }, /* 0000 0000 001 */ { 12, 0x0, G3CODE_INVALID }, /* 0000 0000 0000 */ }; #else extern const tableentry TIFFFaxWhiteCodes[]; extern const tableentry TIFFFaxBlackCodes[]; #endif #endif /* _T4_ */ netpbm-8.2/libtiff/tif_acorn.c0100660000076400000000000002721506747424643015444 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_acorn.c,v 1.1.1.1 1999/07/27 21:50:27 mike Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library RISC OS specific Routines. * Developed out of the Unix version. * Peter Greenham, May 1995 */ #include "tiffiop.h" #include #include /* Low-level file handling ~~~~~~~~~~~~~~~~~~~~~~~ The functions in osfcn.h are unavailable when compiling under C, as it's a C++ header. Therefore they have been implemented here. Now, why have I done it this way? The definitive API library for RISC OS is Jonathan Coxhead's OSLib, which uses heavily optimised ARM assembler or even plain inline SWI calls for maximum performance and minimum runtime size. However, I don't want to make LIBTIFF need that to survive. Therefore I have also emulated the functions using macros to _swi() and _swix() defined in the swis.h header, and borrowing types from kernel.h, which is less efficient but doesn't need any third-party libraries. */ #ifdef INCLUDE_OSLIB #include "osfile.h" #include "osgbpb.h" #include "osargs.h" #include "osfind.h" #else /* OSLIB EMULATION STARTS */ #include "kernel.h" #include "swis.h" /* From oslib:types.h */ typedef unsigned int bits; typedef unsigned char byte; #ifndef TRUE #define TRUE 1 #endif #ifndef FALSE #define FALSE 0 #endif #ifndef NULL #define NULL 0 #endif #ifndef SKIP #define SKIP 0 #endif /* From oslib:os.h */ typedef _kernel_oserror os_error; typedef byte os_f; /* From oslib:osfile.h */ #undef OS_File #define OS_File 0x8 /* From oslib:osgbpb.h */ #undef OS_GBPB #define OS_GBPB 0xC #undef OSGBPB_Write #define OSGBPB_Write 0x2 #undef OSGBPB_Read #define OSGBPB_Read 0x4 extern os_error *xosgbpb_write (os_f file, byte *data, int size, int *unwritten); extern int osgbpb_write (os_f file, byte *data, int size); #define xosgbpb_write(file, data, size, unwritten) \ (os_error*) _swix(OS_GBPB, _IN(0)|_IN(1)|_IN(2)|_IN(3)|_IN(4)|_OUT(3), \ OSGBPB_WriteAt, \ file, \ data, \ size, \ unwritten) #define osgbpb_write(file, data, size) \ _swi(OS_GBPB, _IN(0)|_IN(1)|_IN(2)|_IN(3)|_RETURN(3), \ OSGBPB_Write, \ file, \ data, \ size) extern os_error *xosgbpb_read (os_f file, byte *buffer, int size, int *unread); extern int osgbpb_read (os_f file, byte *buffer, int size); #define xosgbpb_read(file, buffer, size, unread) \ (os_error*) _swix(OS_GBPB, _IN(0)|_IN(1)|_IN(2)|_IN(3)|_OUT(3), \ OSGBPB_Read, \ file, \ buffer, \ size, \ unread) #define osgbpb_read(file, buffer, size) \ _swi(OS_GBPB, _IN(0)|_IN(1)|_IN(2)|_IN(3)|_RETURN(3), \ OSGBPB_Read, \ file, \ buffer, \ size) /* From oslib:osfind.h */ #undef OS_Find #define OS_Find 0xD #undef OSFind_Openin #define OSFind_Openin 0x40 #undef OSFind_Openout #define OSFind_Openout 0x80 #undef OSFind_Openup #define OSFind_Openup 0xC0 #undef OSFind_Close #define OSFind_Close 0x0 #define xosfind_open(reason, file_name, path, file) \ (os_error*) _swix(OS_Find, _IN(0)|_IN(1)|_IN(2)|_OUT(0), \ reason, file_name, path, file) #define osfind_open(reason, file_name, path) \ (os_f) _swi(OS_Find, _IN(0)|_IN(1)|_IN(2)|_RETURN(0), \ reason, file_name, path) extern os_error *xosfind_openin (bits flags, char *file_name, char *path, os_f *file); extern os_f osfind_openin (bits flags, char *file_name, char *path); #define xosfind_openin(flags, file_name, path, file) \ xosfind_open(flags | OSFind_Openin, file_name, path, file) #define osfind_openin(flags, file_name, path) \ osfind_open(flags | OSFind_Openin, file_name, path) extern os_error *xosfind_openout (bits flags, char *file_name, char *path, os_f *file); extern os_f osfind_openout (bits flags, char *file_name, char *path); #define xosfind_openout(flags, file_name, path, file) \ xosfind_open(flags | OSFind_Openout, file_name, path, file) #define osfind_openout(flags, file_name, path) \ osfind_open(flags | OSFind_Openout, file_name, path) extern os_error *xosfind_openup (bits flags, char *file_name, char *path, os_f *file); extern os_f osfind_openup (bits flags, char *file_name, char *path); #define xosfind_openup(flags, file_name, path, file) \ xosfind_open(flags | OSFind_Openup, file_name, path, file) #define osfind_openup(flags, file_name, path) \ osfind_open(flags | OSFind_Openup, file_name, path) extern os_error *xosfind_close (os_f file); extern void osfind_close (os_f file); #define xosfind_close(file) \ (os_error*) _swix(OS_Find, _IN(0)|_IN(1), \ OSFind_Close, \ file) #define osfind_close(file) \ (void) _swi(OS_Find, _IN(0)|_IN(1), \ OSFind_Close, \ file) /* From oslib:osargs.h */ #undef OS_Args #define OS_Args 0x9 #undef OSArgs_ReadPtr #define OSArgs_ReadPtr 0x0 #undef OSArgs_SetPtr #define OSArgs_SetPtr 0x1 #undef OSArgs_ReadExt #define OSArgs_ReadExt 0x2 extern os_error *xosargs_read_ptr (os_f file, int *ptr); extern int osargs_read_ptr (os_f file); #define xosargs_read_ptr(file, ptr) \ (os_error*) _swix(OS_Args, _IN(0)|_IN(1)|_OUT(2), \ OSArgs_ReadPtr, \ file, \ ptr) #define osargs_read_ptr(file) \ _swi(OS_Args, _IN(0)|_IN(1)|_RETURN(2), \ OSArgs_ReadPtr, \ file) extern os_error *xosargs_set_ptr (os_f file, int ptr); extern void osargs_set_ptr (os_f file, int ptr); #define xosargs_set_ptr(file, ptr) \ (os_error*) _swix(OS_Args, _IN(0)|_IN(1)|_IN(2), \ OSArgs_SetPtr, \ file, \ ptr) #define osargs_set_ptr(file, ptr) \ (void) _swi(OS_Args, _IN(0)|_IN(1)|_IN(2), \ OSArgs_SetPtr, \ file, \ ptr) extern os_error *xosargs_read_ext (os_f file, int *ext); extern int osargs_read_ext (os_f file); #define xosargs_read_ext(file, ext) \ (os_error*) _swix(OS_Args, _IN(0)|_IN(1)|_OUT(2), \ OSArgs_ReadExt, \ file, \ ext) #define osargs_read_ext(file) \ _swi(OS_Args, _IN(0)|_IN(1)|_RETURN(2), \ OSArgs_ReadExt, \ file) /* OSLIB EMULATION ENDS */ #endif #ifndef __osfcn_h /* Will be set or not during tiffcomp.h */ /* You get this to compile under C++? Please say how! */ extern int open(const char* name, int flags, int mode) { /* From what I can tell, should return <0 for failure */ os_error* e = (os_error*) 1; /* Cheeky way to use a pointer eh? :-) */ os_f file = (os_f) -1; flags = flags; switch(mode) { case O_RDONLY: { e = xosfind_openin(SKIP, name, SKIP, &file); break; } case O_WRONLY: case O_RDWR|O_CREAT: case O_RDWR|O_CREAT|O_TRUNC: { e = xosfind_openout(SKIP, name, SKIP, &file); break; } case O_RDWR: { e = xosfind_openup(SKIP, name, SKIP, &file); break; } } if (e) { file = (os_f) -1; } return (file); } extern int close(int fd) { return ((int) xosfind_close((os_f) fd)); } extern int write(int fd, const char *buf, int nbytes) { /* Returns number of bytes written */ return (nbytes - osgbpb_write((os_f) fd, (const byte*) buf, nbytes)); } extern int read(int fd, char *buf, int nbytes) { /* Returns number of bytes read */ return (nbytes - osgbpb_read((os_f) fd, (byte*) buf, nbytes)); } extern off_t lseek(int fd, off_t offset, int whence) { int absolute = 0; switch (whence) { case SEEK_SET: { absolute = (int) offset; break; } case SEEK_CUR: { absolute = osargs_read_ptr((os_f) fd) + (int) offset; break; } case SEEK_END: { absolute = osargs_read_ext((os_f) fd) + (int) offset; break; } } osargs_set_ptr((os_f) fd, absolute); return ((off_t) osargs_read_ptr((os_f) fd)); } #endif static tsize_t _tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size) { return ((tsize_t) read((int) fd, buf, (size_t) size)); } static tsize_t _tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size) { return ((tsize_t) write((int) fd, buf, (size_t) size)); } static toff_t _tiffSeekProc(thandle_t fd, toff_t off, int whence) { return ((toff_t) lseek((int) fd, (off_t) off, whence)); } static int _tiffCloseProc(thandle_t fd) { return (close((int) fd)); } static toff_t _tiffSizeProc(thandle_t fd) { return (lseek((int) fd, SEEK_END, SEEK_SET)); } #ifdef HAVE_MMAP #error "I didn't know Acorn had that!" #endif /* !HAVE_MMAP */ static int _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) { (void) fd; (void) pbase; (void) psize; return (0); } static void _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size) { (void) fd; (void) base; (void) size; } /* * Open a TIFF file descriptor for read/writing. */ TIFF* TIFFFdOpen(int fd, const char* name, const char* mode) { TIFF* tif; tif = TIFFClientOpen(name, mode, (thandle_t) fd, _tiffReadProc, _tiffWriteProc, _tiffSeekProc, _tiffCloseProc, _tiffSizeProc, _tiffMapProc, _tiffUnmapProc); if (tif) { tif->tif_fd = fd; } return (tif); } /* * Open a TIFF file for read/writing. */ TIFF* TIFFOpen(const char* name, const char* mode) { static const char module[] = "TIFFOpen"; int m, fd; m = _TIFFgetMode(mode, module); if (m == -1) { return ((TIFF*) 0); } fd = open(name, 0, m); if (fd < 0) { TIFFError(module, "%s: Cannot open", name); return ((TIFF *)0); } return (TIFFFdOpen(fd, name, mode)); } void* _TIFFmalloc(tsize_t s) { return (malloc((size_t) s)); } void _TIFFfree(tdata_t p) { free(p); } void* _TIFFrealloc(tdata_t p, tsize_t s) { return (realloc(p, (size_t) s)); } void _TIFFmemset(tdata_t p, int v, tsize_t c) { memset(p, v, (size_t) c); } void _TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c) { memcpy(d, s, (size_t) c); } int _TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c) { return (memcmp(p1, p2, (size_t) c)); } static void acornWarningHandler(const char* module, const char* fmt, va_list ap) { if (module != NULL) { fprintf(stderr, "%s: ", module); } fprintf(stderr, "Warning, "); vfprintf(stderr, fmt, ap); fprintf(stderr, ".\n"); } TIFFErrorHandler _TIFFwarningHandler = acornWarningHandler; static void acornErrorHandler(const char* module, const char* fmt, va_list ap) { if (module != NULL) { fprintf(stderr, "%s: ", module); } vfprintf(stderr, fmt, ap); fprintf(stderr, ".\n"); } TIFFErrorHandler _TIFFerrorHandler = acornErrorHandler; netpbm-8.2/libtiff/tif_apple.c0100660000076400000000000001416206747424643015440 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_apple.c,v 1.1.1.1 1999/07/27 21:50:27 mike Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library Macintosh-specific routines. * * These routines use only Toolbox and high-level File Manager traps. * They make no calls to the THINK C "unix" compatibility library. Also, * malloc is not used directly but it is still referenced internally by * the ANSI library in rare cases. Heap fragmentation by the malloc ring * buffer is therefore minimized. * * O_RDONLY and O_RDWR are treated identically here. The tif_mode flag is * checked in TIFFWriteCheck(). * * Create below fills in a blank creator signature and sets the file type * to 'TIFF'. It is much better for the application to do this by Create'ing * the file first and TIFFOpen'ing it later. */ #include "tiffiop.h" #include #include #include #if defined(__PPCC__) || defined(__SC__) || defined(__MRC__) || defined(applec) #define CtoPstr c2pstr #endif static tsize_t _tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size) { return (FSRead((short) fd, (long*) &size, (char*) buf) == noErr ? size : (tsize_t) -1); } static tsize_t _tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size) { return (FSWrite((short) fd, (long*) &size, (char*) buf) == noErr ? size : (tsize_t) -1); } static toff_t _tiffSeekProc(thandle_t fd, toff_t off, int whence) { long fpos, size; if (GetEOF((short) fd, &size) != noErr) return EOF; (void) GetFPos((short) fd, &fpos); switch (whence) { case SEEK_CUR: if (off + fpos > size) SetEOF((short) fd, off + fpos); if (SetFPos((short) fd, fsFromMark, off) != noErr) return EOF; break; case SEEK_END: if (off > 0) SetEOF((short) fd, off + size); if (SetFPos((short) fd, fsFromStart, off + size) != noErr) return EOF; break; case SEEK_SET: if (off > size) SetEOF((short) fd, off); if (SetFPos((short) fd, fsFromStart, off) != noErr) return EOF; break; } return (toff_t)(GetFPos((short) fd, &fpos) == noErr ? fpos : EOF); } static int _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) { return (0); } static void _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size) { } static int _tiffCloseProc(thandle_t fd) { return (FSClose((short) fd)); } static toff_t _tiffSizeProc(thandle_t fd) { long size; if (GetEOF((short) fd, &size) != noErr) { TIFFError("_tiffSizeProc", "%s: Cannot get file size"); return (-1L); } return ((toff_t) size); } /* * Open a TIFF file descriptor for read/writing. */ TIFF* TIFFFdOpen(int fd, const char* name, const char* mode) { TIFF* tif; tif = TIFFClientOpen(name, mode, (thandle_t) fd, _tiffReadProc, _tiffWriteProc, _tiffSeekProc, _tiffCloseProc, _tiffSizeProc, _tiffMapProc, _tiffUnmapProc); if (tif) tif->tif_fd = fd; return (tif); } /* * Open a TIFF file for read/writing. */ TIFF* TIFFOpen(const char* name, const char* mode) { static const char module[] = "TIFFOpen"; Str255 pname; FInfo finfo; short fref; OSErr err; strcpy((char*) pname, name); CtoPstr((char*) pname); switch (_TIFFgetMode(mode, module)) { default: return ((TIFF*) 0); case O_RDWR | O_CREAT | O_TRUNC: if (GetFInfo(pname, 0, &finfo) == noErr) FSDelete(pname, 0); /* fall through */ case O_RDWR | O_CREAT: if ((err = GetFInfo(pname, 0, &finfo)) == fnfErr) { if (Create(pname, 0, ' ', 'TIFF') != noErr) goto badCreate; if (FSOpen(pname, 0, &fref) != noErr) goto badOpen; } else if (err == noErr) { if (FSOpen(pname, 0, &fref) != noErr) goto badOpen; } else goto badOpen; break; case O_RDONLY: case O_RDWR: if (FSOpen(pname, 0, &fref) != noErr) goto badOpen; break; } return (TIFFFdOpen((int) fref, name, mode)); badCreate: TIFFError(module, "%s: Cannot create", name); return ((TIFF*) 0); badOpen: TIFFError(module, "%s: Cannot open", name); return ((TIFF*) 0); } void _TIFFmemset(tdata_t p, int v, tsize_t c) { memset(p, v, (size_t) c); } void _TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c) { memcpy(d, s, (size_t) c); } int _TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c) { return (memcmp(p1, p2, (size_t) c)); } tdata_t _TIFFmalloc(tsize_t s) { return (NewPtr((size_t) s)); } void _TIFFfree(tdata_t p) { DisposePtr(p); } tdata_t _TIFFrealloc(tdata_t p, tsize_t s) { Ptr n = p; SetPtrSize(p, (size_t) s); if (MemError() && (n = NewPtr((size_t) s)) != NULL) { BlockMove(p, n, GetPtrSize(p)); DisposePtr(p); } return ((tdata_t) n); } static void appleWarningHandler(const char* module, const char* fmt, va_list ap) { if (module != NULL) fprintf(stderr, "%s: ", module); fprintf(stderr, "Warning, "); vfprintf(stderr, fmt, ap); fprintf(stderr, ".\n"); } TIFFErrorHandler _TIFFwarningHandler = appleWarningHandler; static void appleErrorHandler(const char* module, const char* fmt, va_list ap) { if (module != NULL) fprintf(stderr, "%s: ", module); vfprintf(stderr, fmt, ap); fprintf(stderr, ".\n"); } TIFFErrorHandler _TIFFerrorHandler = appleErrorHandler; netpbm-8.2/libtiff/tif_atari.c0100660000076400000000000001217106747424643015435 0ustar bryanhroot/* "$Header: /cvsroot/osrs/libtiff/libtiff/tif_atari.c,v 1.1.1.1 1999/07/27 21:50:27 mike Exp $" */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library ATARI-specific Routines. */ #include "tiffiop.h" #if defined(__TURBOC__) #include #include #else #include #include #endif #ifndef O_ACCMODE #define O_ACCMODE 3 #endif #include #define AEFILNF -33 static tsize_t _tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size) { long r; r = Fread((int) fd, size, buf); if (r < 0) { errno = (int)-r; r = -1; } return r; } static tsize_t _tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size) { long r; r = Fwrite((int) fd, size, buf); if (r < 0) { errno = (int)-r; r = -1; } return r; } static toff_t _tiffSeekProc(thandle_t fd, off_t off, int whence) { char buf[256]; long current_off, expected_off, new_off; if (whence == SEEK_END || off <= 0) return Fseek(off, (int) fd, whence); current_off = Fseek(0, (int) fd, SEEK_CUR); /* find out where we are */ if (whence == SEEK_SET) expected_off = off; else expected_off = off + current_off; new_off = Fseek(off, (int) fd, whence); if (new_off == expected_off) return new_off; /* otherwise extend file -- zero filling the hole */ if (new_off < 0) /* error? */ new_off = Fseek(0, (int) fd, SEEK_END); /* go to eof */ _TIFFmemset(buf, 0, sizeof(buf)); while (expected_off > new_off) { off = expected_off - new_off; if (off > sizeof(buf)) off = sizeof(buf); if ((current_off = Fwrite((int) fd, off, buf)) != off) return (current_off > 0) ? new_off + current_off : new_off; new_off += off; } return new_off; } static int _tiffCloseProc(thandle_t fd) { long r; r = Fclose((int) fd); if (r < 0) { errno = (int)-r; r = -1; } return (int)r; } static toff_t _tiffSizeProc(thandle_t fd) { long pos, eof; pos = Fseek(0, (int) fd, SEEK_CUR); eof = Fseek(0, (int) fd, SEEK_END); Fseek(pos, (int) fd, SEEK_SET); return eof; } static int _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) { return (0); } static void _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size) { } /* * Open a TIFF file descriptor for read/writing. */ TIFF* TIFFFdOpen(int fd, const char* name, const char* mode) { TIFF* tif; tif = TIFFClientOpen(name, mode, (thandle_t) fd, _tiffReadProc, _tiffWriteProc, _tiffSeekProc, _tiffCloseProc, _tiffSizeProc, _tiffMapProc, _tiffUnmapProc); if (tif) tif->tif_fd = fd; return (tif); } /* * Open a TIFF file for read/writing. */ TIFF* TIFFOpen(const char* name, const char* mode) { static const char module[] = "TIFFOpen"; int m; long fd; m = _TIFFgetMode(mode, module); if (m == -1) return ((TIFF*)0); if (m & O_TRUNC) { fd = Fcreate(name, 0); } else { fd = Fopen(name, m & O_ACCMODE); if (fd == AEFILNF && m & O_CREAT) fd = Fcreate(name, 0); } if (fd < 0) errno = (int)fd; if (fd < 0) { TIFFError(module, "%s: Cannot open", name); return ((TIFF*)0); } return (TIFFFdOpen(fd, name, mode)); } #include tdata_t _TIFFmalloc(tsize_t s) { return (malloc((size_t) s)); } void _TIFFfree(tdata_t p) { free(p); } tdata_t _TIFFrealloc(tdata_t p, tsize_t s) { return (realloc(p, (size_t) s)); } void _TIFFmemset(tdata_t p, int v, size_t c) { memset(p, v, (size_t) c); } void _TIFFmemcpy(tdata_t d, const tdata_t s, size_t c) { memcpy(d, s, (size_t) c); } int _TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c) { return (memcmp(p1, p2, (size_t) c)); } static void atariWarningHandler(const char* module, const char* fmt, va_list ap) { if (module != NULL) fprintf(stderr, "%s: ", module); fprintf(stderr, "Warning, "); vfprintf(stderr, fmt, ap); fprintf(stderr, ".\n"); } TIFFErrorHandler _TIFFwarningHandler = atariWarningHandler; static void atariErrorHandler(const char* module, const char* fmt, va_list ap) { if (module != NULL) fprintf(stderr, "%s: ", module); vfprintf(stderr, fmt, ap); fprintf(stderr, ".\n"); } TIFFErrorHandler _TIFFerrorHandler = atariErrorHandler; netpbm-8.2/libtiff/tif_aux.c0100660000076400000000000001366506747424643015143 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_aux.c,v 1.1.1.1 1999/07/27 21:50:27 mike Exp $ */ /* * Copyright (c) 1991-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library. * * Auxiliary Support Routines. */ #include "tiffiop.h" #ifdef COLORIMETRY_SUPPORT #include static void TIFFDefaultTransferFunction(TIFFDirectory* td) { uint16 **tf = td->td_transferfunction; long i, n = 1<td_bitspersample; tf[0] = (uint16 *)_TIFFmalloc(n * sizeof (uint16)); tf[0][0] = 0; for (i = 1; i < n; i++) { double t = (double)i/((double) n-1.); tf[0][i] = (uint16)floor(65535.*pow(t, 2.2) + .5); } if (td->td_samplesperpixel - td->td_extrasamples > 1) { tf[1] = (uint16 *)_TIFFmalloc(n * sizeof (uint16)); _TIFFmemcpy(tf[1], tf[0], n * sizeof (uint16)); tf[2] = (uint16 *)_TIFFmalloc(n * sizeof (uint16)); _TIFFmemcpy(tf[2], tf[0], n * sizeof (uint16)); } } static void TIFFDefaultRefBlackWhite(TIFFDirectory* td) { int i; td->td_refblackwhite = (float *)_TIFFmalloc(6*sizeof (float)); for (i = 0; i < 3; i++) { td->td_refblackwhite[2*i+0] = 0; td->td_refblackwhite[2*i+1] = (float)((1L<td_bitspersample)-1L); } } #endif /* * Like TIFFGetField, but return any default * value if the tag is not present in the directory. * * NB: We use the value in the directory, rather than * explcit values so that defaults exist only one * place in the library -- in TIFFDefaultDirectory. */ int TIFFVGetFieldDefaulted(TIFF* tif, ttag_t tag, va_list ap) { TIFFDirectory *td = &tif->tif_dir; if (TIFFVGetField(tif, tag, ap)) return (1); switch (tag) { case TIFFTAG_SUBFILETYPE: *va_arg(ap, uint32 *) = td->td_subfiletype; return (1); case TIFFTAG_BITSPERSAMPLE: *va_arg(ap, uint16 *) = td->td_bitspersample; return (1); case TIFFTAG_THRESHHOLDING: *va_arg(ap, uint16 *) = td->td_threshholding; return (1); case TIFFTAG_FILLORDER: *va_arg(ap, uint16 *) = td->td_fillorder; return (1); case TIFFTAG_ORIENTATION: *va_arg(ap, uint16 *) = td->td_orientation; return (1); case TIFFTAG_SAMPLESPERPIXEL: *va_arg(ap, uint16 *) = td->td_samplesperpixel; return (1); case TIFFTAG_ROWSPERSTRIP: *va_arg(ap, uint32 *) = td->td_rowsperstrip; return (1); case TIFFTAG_MINSAMPLEVALUE: *va_arg(ap, uint16 *) = td->td_minsamplevalue; return (1); case TIFFTAG_MAXSAMPLEVALUE: *va_arg(ap, uint16 *) = td->td_maxsamplevalue; return (1); case TIFFTAG_PLANARCONFIG: *va_arg(ap, uint16 *) = td->td_planarconfig; return (1); case TIFFTAG_RESOLUTIONUNIT: *va_arg(ap, uint16 *) = td->td_resolutionunit; return (1); #ifdef CMYK_SUPPORT case TIFFTAG_DOTRANGE: *va_arg(ap, uint16 *) = 0; *va_arg(ap, uint16 *) = (1<td_bitspersample)-1; return (1); case TIFFTAG_INKSET: *va_arg(ap, uint16 *) = td->td_inkset; return (1); case TIFFTAG_NUMBEROFINKS: *va_arg(ap, uint16 *) = td->td_ninks; return (1); #endif case TIFFTAG_EXTRASAMPLES: *va_arg(ap, uint16 *) = td->td_extrasamples; *va_arg(ap, uint16 **) = td->td_sampleinfo; return (1); case TIFFTAG_MATTEING: *va_arg(ap, uint16 *) = (td->td_extrasamples == 1 && td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA); return (1); case TIFFTAG_TILEDEPTH: *va_arg(ap, uint32 *) = td->td_tiledepth; return (1); case TIFFTAG_DATATYPE: *va_arg(ap, uint16 *) = td->td_sampleformat-1; return (1); case TIFFTAG_IMAGEDEPTH: *va_arg(ap, uint32 *) = td->td_imagedepth; return (1); #ifdef YCBCR_SUPPORT case TIFFTAG_YCBCRCOEFFICIENTS: if (!td->td_ycbcrcoeffs) { td->td_ycbcrcoeffs = (float *) _TIFFmalloc(3*sizeof (float)); /* defaults are from CCIR Recommendation 601-1 */ td->td_ycbcrcoeffs[0] = 0.299f; td->td_ycbcrcoeffs[1] = 0.587f; td->td_ycbcrcoeffs[2] = 0.114f; } *va_arg(ap, float **) = td->td_ycbcrcoeffs; return (1); case TIFFTAG_YCBCRSUBSAMPLING: *va_arg(ap, uint16 *) = td->td_ycbcrsubsampling[0]; *va_arg(ap, uint16 *) = td->td_ycbcrsubsampling[1]; return (1); case TIFFTAG_YCBCRPOSITIONING: *va_arg(ap, uint16 *) = td->td_ycbcrpositioning; return (1); #endif #ifdef COLORIMETRY_SUPPORT case TIFFTAG_TRANSFERFUNCTION: if (!td->td_transferfunction[0]) TIFFDefaultTransferFunction(td); *va_arg(ap, uint16 **) = td->td_transferfunction[0]; if (td->td_samplesperpixel - td->td_extrasamples > 1) { *va_arg(ap, uint16 **) = td->td_transferfunction[1]; *va_arg(ap, uint16 **) = td->td_transferfunction[2]; } return (1); case TIFFTAG_REFERENCEBLACKWHITE: if (!td->td_refblackwhite) TIFFDefaultRefBlackWhite(td); *va_arg(ap, float **) = td->td_refblackwhite; return (1); #endif } return (0); } /* * Like TIFFGetField, but return any default * value if the tag is not present in the directory. */ int TIFFGetFieldDefaulted(TIFF* tif, ttag_t tag, ...) { int ok; va_list ap; va_start(ap, tag); ok = TIFFVGetFieldDefaulted(tif, tag, ap); va_end(ap); return (ok); } netpbm-8.2/libtiff/tif_close.c0100660000076400000000000000344206747424643015443 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_close.c,v 1.1.1.1 1999/07/27 21:50:27 mike Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library. */ #include "tiffiop.h" void TIFFClose(TIFF* tif) { if (tif->tif_mode != O_RDONLY) /* * Flush buffered data and directory (if dirty). */ TIFFFlush(tif); (*tif->tif_cleanup)(tif); TIFFFreeDirectory(tif); if (tif->tif_rawdata && (tif->tif_flags&TIFF_MYBUFFER)) _TIFFfree(tif->tif_rawdata); if (isMapped(tif)) TIFFUnmapFileContents(tif, tif->tif_base, tif->tif_size); (void) TIFFCloseFile(tif); if (tif->tif_fieldinfo) _TIFFfree(tif->tif_fieldinfo); _TIFFfree(tif); } netpbm-8.2/libtiff/tif_codec.c0100660000076400000000000000737107023237712015403 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_codec.c,v 1.2 1999/12/07 17:11:38 mwelles Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library * * Builtin Compression Scheme Configuration Support. */ #include "tiffiop.h" static int NotConfigured(TIFF*, int); #ifndef LZW_SUPPORT #define TIFFInitLZW NotConfigured #endif #ifndef PACKBITS_SUPPORT #define TIFFInitPackbits NotConfigured #endif #ifndef THUNDER_SUPPORT #define TIFFInitThunderScan NotConfigured #endif #ifndef NEXT_SUPPORT #define TIFFInitNeXT NotConfigured #endif #ifndef JPEG_SUPPORT #define TIFFInitJPEG NotConfigured #endif #ifndef OJPEG_SUPPORT #define TIFFInitOJPEG NotConfigured #endif #ifndef CCITT_SUPPORT #define TIFFInitCCITTRLE NotConfigured #define TIFFInitCCITTRLEW NotConfigured #define TIFFInitCCITTFax3 NotConfigured #define TIFFInitCCITTFax4 NotConfigured #endif #ifndef JBIG_SUPPORT #define TIFFInitJBIG NotConfigured #endif #ifndef ZIP_SUPPORT #define TIFFInitZIP NotConfigured #endif #ifndef PIXARLOG_SUPPORT #define TIFFInitPixarLog NotConfigured #endif #ifndef LOGLUV_SUPPORT #define TIFFInitSGILog NotConfigured #endif /* * Compression schemes statically built into the library. */ #ifdef VMS const TIFFCodec _TIFFBuiltinCODECS[] = { #else TIFFCodec _TIFFBuiltinCODECS[] = { #endif { "None", COMPRESSION_NONE, TIFFInitDumpMode }, { "LZW", COMPRESSION_LZW, TIFFInitLZW }, { "PackBits", COMPRESSION_PACKBITS, TIFFInitPackBits }, { "ThunderScan", COMPRESSION_THUNDERSCAN,TIFFInitThunderScan }, { "NeXT", COMPRESSION_NEXT, TIFFInitNeXT }, { "JPEG", COMPRESSION_JPEG, TIFFInitJPEG }, { "Old-style JPEG", COMPRESSION_OJPEG, TIFFInitOJPEG }, { "CCITT RLE", COMPRESSION_CCITTRLE, TIFFInitCCITTRLE }, { "CCITT RLE/W", COMPRESSION_CCITTRLEW, TIFFInitCCITTRLEW }, { "CCITT Group 3", COMPRESSION_CCITTFAX3, TIFFInitCCITTFax3 }, { "CCITT Group 4", COMPRESSION_CCITTFAX4, TIFFInitCCITTFax4 }, { "ISO JBIG", COMPRESSION_JBIG, TIFFInitJBIG }, { "Deflate", COMPRESSION_DEFLATE, TIFFInitZIP }, { "AdobeDeflate", COMPRESSION_ADOBE_DEFLATE , TIFFInitZIP }, { "PixarLog", COMPRESSION_PIXARLOG, TIFFInitPixarLog }, { "SGILog", COMPRESSION_SGILOG, TIFFInitSGILog }, { "SGILog24", COMPRESSION_SGILOG24, TIFFInitSGILog }, { NULL } }; static int _notConfigured(TIFF* tif) { const TIFFCodec* c = TIFFFindCODEC(tif->tif_dir.td_compression); TIFFError(tif->tif_name, "%s compression support is not configured", c->name); return (0); } static int NotConfigured(TIFF* tif, int scheme) { tif->tif_setupdecode = _notConfigured; tif->tif_setupencode = _notConfigured; return (1); } netpbm-8.2/libtiff/tif_compress.c0100660000076400000000000001413307027731307016156 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_compress.c,v 1.4 1999/12/21 17:03:03 mwelles Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library * * Compression Scheme Configuration Support. */ #include "tiffiop.h" static int TIFFNoEncode(TIFF* tif, char* method) { const TIFFCodec* c = TIFFFindCODEC(tif->tif_dir.td_compression); if (c) { if (! strncmp(c->name, "LZW", 3) ){ TIFFError(tif->tif_name, "%s %s encoding is no longer implemented due to Unisys patent enforcement", c->name, method); } else { TIFFError(tif->tif_name, "%s %s encoding is not implemented", c->name, method); } } else { TIFFError(tif->tif_name, "Compression scheme %u %s encoding is not implemented", tif->tif_dir.td_compression, method); } return (-1); } int _TIFFNoRowEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s) { (void) pp; (void) cc; (void) s; return (TIFFNoEncode(tif, "scanline")); } int _TIFFNoStripEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s) { (void) pp; (void) cc; (void) s; return (TIFFNoEncode(tif, "strip")); } int _TIFFNoTileEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s) { (void) pp; (void) cc; (void) s; return (TIFFNoEncode(tif, "tile")); } static int TIFFNoDecode(TIFF* tif, char* method) { const TIFFCodec* c = TIFFFindCODEC(tif->tif_dir.td_compression); if (c) TIFFError(tif->tif_name, "%s %s decoding is not implemented", c->name, method); else TIFFError(tif->tif_name, "Compression scheme %u %s decoding is not implemented", tif->tif_dir.td_compression, method); return (-1); } int _TIFFNoRowDecode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s) { (void) pp; (void) cc; (void) s; return (TIFFNoDecode(tif, "scanline")); } int _TIFFNoStripDecode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s) { (void) pp; (void) cc; (void) s; return (TIFFNoDecode(tif, "strip")); } int _TIFFNoTileDecode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s) { (void) pp; (void) cc; (void) s; return (TIFFNoDecode(tif, "tile")); } int _TIFFNoSeek(TIFF* tif, uint32 off) { (void) off; TIFFError(tif->tif_name, "Compression algorithm does not support random access"); return (0); } int _TIFFNoPreCode(TIFF* tif, tsample_t s) { (void) tif; (void) s; return (1); } static int _TIFFtrue(TIFF* tif) { (void) tif; return (1); } static void _TIFFvoid(TIFF* tif) { (void) tif; } void _TIFFSetDefaultCompressionState(TIFF* tif) { tif->tif_setupdecode = _TIFFtrue; tif->tif_predecode = _TIFFNoPreCode; tif->tif_decoderow = _TIFFNoRowDecode; tif->tif_decodestrip = _TIFFNoStripDecode; tif->tif_decodetile = _TIFFNoTileDecode; tif->tif_setupencode = _TIFFtrue; tif->tif_preencode = _TIFFNoPreCode; tif->tif_postencode = _TIFFtrue; tif->tif_encoderow = _TIFFNoRowEncode; tif->tif_encodestrip = _TIFFNoStripEncode; tif->tif_encodetile = _TIFFNoTileEncode; tif->tif_close = _TIFFvoid; tif->tif_seek = _TIFFNoSeek; tif->tif_cleanup = _TIFFvoid; tif->tif_defstripsize = _TIFFDefaultStripSize; tif->tif_deftilesize = _TIFFDefaultTileSize; tif->tif_flags &= ~TIFF_NOBITREV; } int TIFFSetCompressionScheme(TIFF* tif, int scheme) { const TIFFCodec *c = TIFFFindCODEC((uint16) scheme); _TIFFSetDefaultCompressionState(tif); /* * Don't treat an unknown compression scheme as an error. * This permits applications to open files with data that * the library does not have builtin support for, but which * may still be meaningful. */ return (c ? (*c->init)(tif, scheme) : 1); } /* * Other compression schemes may be registered. Registered * schemes can also override the builtin versions provided * by this library. */ typedef struct _codec { struct _codec* next; TIFFCodec* info; } codec_t; static codec_t* registeredCODECS = NULL; const TIFFCodec* TIFFFindCODEC(uint16 scheme) { const TIFFCodec* c; codec_t* cd; for (cd = registeredCODECS; cd; cd = cd->next) if (cd->info->scheme == scheme) return ((const TIFFCodec*) cd->info); for (c = _TIFFBuiltinCODECS; c->name; c++) if (c->scheme == scheme) return (c); return ((const TIFFCodec*) 0); } TIFFCodec* TIFFRegisterCODEC(uint16 scheme, const char* name, TIFFInitMethod init) { codec_t* cd = (codec_t*) _TIFFmalloc(sizeof (codec_t) + sizeof (TIFFCodec) + strlen(name)+1); if (cd != NULL) { cd->info = (TIFFCodec*) ((tidata_t) cd + sizeof (codec_t)); cd->info->name = (char*) ((tidata_t) cd->info + sizeof (TIFFCodec)); strcpy(cd->info->name, name); cd->info->scheme = scheme; cd->info->init = init; cd->next = registeredCODECS; registeredCODECS = cd; } else TIFFError("TIFFRegisterCODEC", "No space to register compression scheme %s", name); return (cd->info); } void TIFFUnRegisterCODEC(TIFFCodec* c) { codec_t* cd; codec_t** pcd; for (pcd = ®isteredCODECS; (cd = *pcd); pcd = &cd->next) if (cd->info == c) { *pcd = cd->next; _TIFFfree(cd); return; } TIFFError("TIFFUnRegisterCODEC", "Cannot remove compression scheme %s; not registered", c->name); } netpbm-8.2/libtiff/tif_dir.c0100660000076400000000000010542707027731307015110 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_dir.c,v 1.6 1999/12/21 17:03:03 mwelles Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library. * * Directory Tag Get & Set Routines. * (and also some miscellaneous stuff) */ #include "tiffiop.h" /* * These are used in the backwards compatibility code... */ #define DATATYPE_VOID 0 /* !untyped data */ #define DATATYPE_INT 1 /* !signed integer data */ #define DATATYPE_UINT 2 /* !unsigned integer data */ #define DATATYPE_IEEEFP 3 /* !IEEE floating point data */ void _TIFFsetByteArray(void** vpp, void* vp, long n) { if (*vpp) _TIFFfree(*vpp), *vpp = 0; if (vp && (*vpp = (void*) _TIFFmalloc(n))) _TIFFmemcpy(*vpp, vp, n); } void _TIFFsetString(char** cpp, char* cp) { _TIFFsetByteArray((void**) cpp, (void*) cp, (long) (strlen(cp)+1)); } void _TIFFsetNString(char** cpp, char* cp, long n) { _TIFFsetByteArray((void**) cpp, (void*) cp, n); } void _TIFFsetShortArray(uint16** wpp, uint16* wp, long n) { _TIFFsetByteArray((void**) wpp, (void*) wp, n*sizeof (uint16)); } void _TIFFsetLongArray(uint32** lpp, uint32* lp, long n) { _TIFFsetByteArray((void**) lpp, (void*) lp, n*sizeof (uint32)); } void _TIFFsetFloatArray(float** fpp, float* fp, long n) { _TIFFsetByteArray((void**) fpp, (void*) fp, n*sizeof (float)); } void _TIFFsetDoubleArray(double** dpp, double* dp, long n) { _TIFFsetByteArray((void**) dpp, (void*) dp, n*sizeof (double)); } /* * Install extra samples information. */ static int setExtraSamples(TIFFDirectory* td, va_list ap, int* v) { uint16* va; int i; *v = va_arg(ap, int); if ((uint16) *v > td->td_samplesperpixel) return (0); va = va_arg(ap, uint16*); if (*v > 0 && va == NULL) /* typically missing param */ return (0); for (i = 0; i < *v; i++) if (va[i] > EXTRASAMPLE_UNASSALPHA) return (0); td->td_extrasamples = (uint16) *v; _TIFFsetShortArray(&td->td_sampleinfo, va, td->td_extrasamples); return (1); } #ifdef CMYK_SUPPORT static int checkInkNamesString(TIFF* tif, int slen, const char* s) { TIFFDirectory* td = &tif->tif_dir; int i = td->td_samplesperpixel; if (slen > 0) { const char* ep = s+slen; const char* cp = s; for (; i > 0; i--) { for (; *cp != '\0'; cp++) if (cp >= ep) goto bad; cp++; /* skip \0 */ } return (cp-s); } bad: TIFFError("TIFFSetField", "%s: Invalid InkNames value; expecting %d names, found %d", tif->tif_name, td->td_samplesperpixel, td->td_samplesperpixel-i); return (0); } #endif static int _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap) { TIFFDirectory* td = &tif->tif_dir; int status = 1; uint32 v32; int i, v; double d; char* s; switch (tag) { case TIFFTAG_SUBFILETYPE: td->td_subfiletype = va_arg(ap, uint32); break; case TIFFTAG_IMAGEWIDTH: td->td_imagewidth = va_arg(ap, uint32); break; case TIFFTAG_IMAGELENGTH: td->td_imagelength = va_arg(ap, uint32); break; case TIFFTAG_BITSPERSAMPLE: td->td_bitspersample = (uint16) va_arg(ap, int); /* * If the data require post-decoding processing * to byte-swap samples, set it up here. Note * that since tags are required to be ordered, * compression code can override this behaviour * in the setup method if it wants to roll the * post decoding work in with its normal work. */ if (tif->tif_flags & TIFF_SWAB) { if (td->td_bitspersample == 16) tif->tif_postdecode = _TIFFSwab16BitData; else if (td->td_bitspersample == 32) tif->tif_postdecode = _TIFFSwab32BitData; else if (td->td_bitspersample == 64) tif->tif_postdecode = _TIFFSwab64BitData; } break; case TIFFTAG_COMPRESSION: v = va_arg(ap, int) & 0xffff; /* * If we're changing the compression scheme, * the notify the previous module so that it * can cleanup any state it's setup. */ if (TIFFFieldSet(tif, FIELD_COMPRESSION)) { if (td->td_compression == v) break; (*tif->tif_cleanup)(tif); tif->tif_flags &= ~TIFF_CODERSETUP; } /* * Setup new compression routine state. */ if ( ! tif->tif_mode == O_RDONLY ) { /* Handle removal of LZW compression */ if ( v == COMPRESSION_LZW ) { TIFFError(tif->tif_name, "LZW compression no longer supported due to Unisys patent enforcement"); v=COMPRESSION_NONE; } } if( (status = TIFFSetCompressionScheme(tif, v)) != 0 ) td->td_compression = v; break; case TIFFTAG_PHOTOMETRIC: td->td_photometric = (uint16) va_arg(ap, int); break; case TIFFTAG_THRESHHOLDING: td->td_threshholding = (uint16) va_arg(ap, int); break; case TIFFTAG_FILLORDER: v = va_arg(ap, int); if (v != FILLORDER_LSB2MSB && v != FILLORDER_MSB2LSB) goto badvalue; td->td_fillorder = (uint16) v; break; case TIFFTAG_DOCUMENTNAME: _TIFFsetString(&td->td_documentname, va_arg(ap, char*)); break; case TIFFTAG_ARTIST: _TIFFsetString(&td->td_artist, va_arg(ap, char*)); break; case TIFFTAG_DATETIME: _TIFFsetString(&td->td_datetime, va_arg(ap, char*)); break; case TIFFTAG_HOSTCOMPUTER: _TIFFsetString(&td->td_hostcomputer, va_arg(ap, char*)); break; case TIFFTAG_IMAGEDESCRIPTION: _TIFFsetString(&td->td_imagedescription, va_arg(ap, char*)); break; case TIFFTAG_MAKE: _TIFFsetString(&td->td_make, va_arg(ap, char*)); break; case TIFFTAG_MODEL: _TIFFsetString(&td->td_model, va_arg(ap, char*)); break; case TIFFTAG_SOFTWARE: _TIFFsetString(&td->td_software, va_arg(ap, char*)); break; case TIFFTAG_ORIENTATION: v = va_arg(ap, int); if (v < ORIENTATION_TOPLEFT || ORIENTATION_LEFTBOT < v) { TIFFWarning(tif->tif_name, "Bad value %ld for \"%s\" tag ignored", v, _TIFFFieldWithTag(tif, tag)->field_name); } else td->td_orientation = (uint16) v; break; case TIFFTAG_SAMPLESPERPIXEL: /* XXX should cross check -- e.g. if pallette, then 1 */ v = va_arg(ap, int); if (v == 0) goto badvalue; td->td_samplesperpixel = (uint16) v; break; case TIFFTAG_ROWSPERSTRIP: v32 = va_arg(ap, uint32); if (v32 == 0) goto badvalue32; td->td_rowsperstrip = v32; if (!TIFFFieldSet(tif, FIELD_TILEDIMENSIONS)) { td->td_tilelength = v32; td->td_tilewidth = td->td_imagewidth; } break; case TIFFTAG_MINSAMPLEVALUE: td->td_minsamplevalue = (uint16) va_arg(ap, int); break; case TIFFTAG_MAXSAMPLEVALUE: td->td_maxsamplevalue = (uint16) va_arg(ap, int); break; case TIFFTAG_SMINSAMPLEVALUE: td->td_sminsamplevalue = (double) va_arg(ap, dblparam_t); break; case TIFFTAG_SMAXSAMPLEVALUE: td->td_smaxsamplevalue = (double) va_arg(ap, dblparam_t); break; case TIFFTAG_XRESOLUTION: td->td_xresolution = (float) va_arg(ap, dblparam_t); break; case TIFFTAG_YRESOLUTION: td->td_yresolution = (float) va_arg(ap, dblparam_t); break; case TIFFTAG_PLANARCONFIG: v = va_arg(ap, int); if (v != PLANARCONFIG_CONTIG && v != PLANARCONFIG_SEPARATE) goto badvalue; td->td_planarconfig = (uint16) v; break; case TIFFTAG_PAGENAME: _TIFFsetString(&td->td_pagename, va_arg(ap, char*)); break; case TIFFTAG_XPOSITION: td->td_xposition = (float) va_arg(ap, dblparam_t); break; case TIFFTAG_YPOSITION: td->td_yposition = (float) va_arg(ap, dblparam_t); break; case TIFFTAG_RESOLUTIONUNIT: v = va_arg(ap, int); if (v < RESUNIT_NONE || RESUNIT_CENTIMETER < v) goto badvalue; td->td_resolutionunit = (uint16) v; break; case TIFFTAG_PAGENUMBER: td->td_pagenumber[0] = (uint16) va_arg(ap, int); td->td_pagenumber[1] = (uint16) va_arg(ap, int); break; case TIFFTAG_HALFTONEHINTS: td->td_halftonehints[0] = (uint16) va_arg(ap, int); td->td_halftonehints[1] = (uint16) va_arg(ap, int); break; case TIFFTAG_COLORMAP: v32 = (uint32)(1L<td_bitspersample); _TIFFsetShortArray(&td->td_colormap[0], va_arg(ap, uint16*), v32); _TIFFsetShortArray(&td->td_colormap[1], va_arg(ap, uint16*), v32); _TIFFsetShortArray(&td->td_colormap[2], va_arg(ap, uint16*), v32); break; case TIFFTAG_EXTRASAMPLES: if (!setExtraSamples(td, ap, &v)) goto badvalue; break; case TIFFTAG_MATTEING: td->td_extrasamples = (uint16) (va_arg(ap, int) != 0); if (td->td_extrasamples) { uint16 sv = EXTRASAMPLE_ASSOCALPHA; _TIFFsetShortArray(&td->td_sampleinfo, &sv, 1); } break; case TIFFTAG_TILEWIDTH: v32 = va_arg(ap, uint32); if (v32 % 16) { if (tif->tif_mode != O_RDONLY) goto badvalue32; TIFFWarning(tif->tif_name, "Nonstandard tile width %d, convert file", v32); } td->td_tilewidth = v32; tif->tif_flags |= TIFF_ISTILED; break; case TIFFTAG_TILELENGTH: v32 = va_arg(ap, uint32); if (v32 % 16) { if (tif->tif_mode != O_RDONLY) goto badvalue32; TIFFWarning(tif->tif_name, "Nonstandard tile length %d, convert file", v32); } td->td_tilelength = v32; tif->tif_flags |= TIFF_ISTILED; break; case TIFFTAG_TILEDEPTH: v32 = va_arg(ap, uint32); if (v32 == 0) goto badvalue32; td->td_tiledepth = v32; break; case TIFFTAG_DATATYPE: v = va_arg(ap, int); switch (v) { case DATATYPE_VOID: v = SAMPLEFORMAT_VOID; break; case DATATYPE_INT: v = SAMPLEFORMAT_INT; break; case DATATYPE_UINT: v = SAMPLEFORMAT_UINT; break; case DATATYPE_IEEEFP: v = SAMPLEFORMAT_IEEEFP;break; default: goto badvalue; } td->td_sampleformat = (uint16) v; break; case TIFFTAG_SAMPLEFORMAT: v = va_arg(ap, int); if (v < SAMPLEFORMAT_UINT || SAMPLEFORMAT_VOID < v) goto badvalue; td->td_sampleformat = (uint16) v; break; case TIFFTAG_IMAGEDEPTH: td->td_imagedepth = va_arg(ap, uint32); break; case TIFFTAG_STONITS: d = va_arg(ap, dblparam_t); if (d <= 0.) goto badvaluedbl; td->td_stonits = d; break; /* Begin Pixar Tags */ case TIFFTAG_PIXAR_IMAGEFULLWIDTH: td->td_imagefullwidth = va_arg(ap, uint32); break; case TIFFTAG_PIXAR_IMAGEFULLLENGTH: td->td_imagefulllength = va_arg(ap, uint32); break; case TIFFTAG_PIXAR_TEXTUREFORMAT: _TIFFsetString(&td->td_textureformat, va_arg(ap, char*)); break; case TIFFTAG_PIXAR_WRAPMODES: _TIFFsetString(&td->td_wrapmodes, va_arg(ap, char*)); break; case TIFFTAG_PIXAR_FOVCOT: td->td_fovcot = (float) va_arg(ap, dblparam_t); break; case TIFFTAG_PIXAR_MATRIX_WORLDTOSCREEN: _TIFFsetFloatArray(&td->td_matrixWorldToScreen, va_arg(ap, float*), 16); break; case TIFFTAG_PIXAR_MATRIX_WORLDTOCAMERA: _TIFFsetFloatArray(&td->td_matrixWorldToCamera, va_arg(ap, float*), 16); break; /* End Pixar Tags */ #if SUBIFD_SUPPORT case TIFFTAG_SUBIFD: if ((tif->tif_flags & TIFF_INSUBIFD) == 0) { td->td_nsubifd = (uint16) va_arg(ap, int); _TIFFsetLongArray(&td->td_subifd, va_arg(ap, uint32*), (long) td->td_nsubifd); } else { TIFFError(tif->tif_name, "Sorry, cannot nest SubIFDs"); status = 0; } break; #endif #ifdef YCBCR_SUPPORT case TIFFTAG_YCBCRCOEFFICIENTS: _TIFFsetFloatArray(&td->td_ycbcrcoeffs, va_arg(ap, float*), 3); break; case TIFFTAG_YCBCRPOSITIONING: td->td_ycbcrpositioning = (uint16) va_arg(ap, int); break; case TIFFTAG_YCBCRSUBSAMPLING: td->td_ycbcrsubsampling[0] = (uint16) va_arg(ap, int); td->td_ycbcrsubsampling[1] = (uint16) va_arg(ap, int); break; #endif #ifdef COLORIMETRY_SUPPORT case TIFFTAG_WHITEPOINT: _TIFFsetFloatArray(&td->td_whitepoint, va_arg(ap, float*), 2); break; case TIFFTAG_PRIMARYCHROMATICITIES: _TIFFsetFloatArray(&td->td_primarychromas, va_arg(ap, float*), 6); break; case TIFFTAG_TRANSFERFUNCTION: v = (td->td_samplesperpixel - td->td_extrasamples) > 1 ? 3 : 1; for (i = 0; i < v; i++) _TIFFsetShortArray(&td->td_transferfunction[i], va_arg(ap, uint16*), 1L<td_bitspersample); break; case TIFFTAG_REFERENCEBLACKWHITE: /* XXX should check for null range */ _TIFFsetFloatArray(&td->td_refblackwhite, va_arg(ap, float*), 6); break; #endif #ifdef CMYK_SUPPORT case TIFFTAG_INKSET: td->td_inkset = (uint16) va_arg(ap, int); break; case TIFFTAG_DOTRANGE: /* XXX should check for null range */ td->td_dotrange[0] = (uint16) va_arg(ap, int); td->td_dotrange[1] = (uint16) va_arg(ap, int); break; case TIFFTAG_INKNAMES: i = va_arg(ap, int); s = va_arg(ap, char*); i = checkInkNamesString(tif, i, s); status = i > 0; if( i > 0 ) { _TIFFsetNString(&td->td_inknames, s, i); td->td_inknameslen = i; } break; case TIFFTAG_NUMBEROFINKS: td->td_ninks = (uint16) va_arg(ap, int); break; case TIFFTAG_TARGETPRINTER: _TIFFsetString(&td->td_targetprinter, va_arg(ap, char*)); break; #endif #ifdef ICC_SUPPORT case TIFFTAG_ICCPROFILE: td->td_profileLength = (uint32) va_arg(ap, uint32); _TIFFsetByteArray(&td->td_profileData, va_arg(ap, void*), td->td_profileLength); break; #endif #ifdef PHOTOSHOP_SUPPORT case TIFFTAG_PHOTOSHOP: td->td_photoshopLength = (uint32) va_arg(ap, uint32); _TIFFsetByteArray (&td->td_photoshopData, va_arg(ap, void*), td->td_photoshopLength); break; #endif #ifdef IPTC_SUPPORT case TIFFTAG_RICHTIFFIPTC: td->td_richtiffiptcLength = (uint32) va_arg(ap, uint32); #ifdef PHOTOSHOP_SUPPORT _TIFFsetLongArray ((uint32**)&td->td_richtiffiptcData, va_arg(ap, uint32*), td->td_richtiffiptcLength); #else _TIFFsetByteArray (&td->td_photoshopData, va_arg(ap, void*), td->td_photoshopLength); #endif break; #endif default: /* * This can happen if multiple images are open with * different codecs which have private tags. The * global tag information table may then have tags * that are valid for one file but not the other. * If the client tries to set a tag that is not valid * for the image's codec then we'll arrive here. This * happens, for example, when tiffcp is used to convert * between compression schemes and codec-specific tags * are blindly copied. */ TIFFError("TIFFSetField", "%s: Invalid %stag \"%s\" (not supported by codec)", tif->tif_name, isPseudoTag(tag) ? "pseduo-" : "", _TIFFFieldWithTag(tif, tag)->field_name); status = 0; break; } if (status) { TIFFSetFieldBit(tif, _TIFFFieldWithTag(tif, tag)->field_bit); tif->tif_flags |= TIFF_DIRTYDIRECT; } va_end(ap); return (status); badvalue: TIFFError(tif->tif_name, "%d: Bad value for \"%s\"", v, _TIFFFieldWithTag(tif, tag)->field_name); va_end(ap); return (0); badvalue32: TIFFError(tif->tif_name, "%ld: Bad value for \"%s\"", v32, _TIFFFieldWithTag(tif, tag)->field_name); va_end(ap); return (0); badvaluedbl: TIFFError(tif->tif_name, "%f: Bad value for \"%s\"", d, _TIFFFieldWithTag(tif, tag)->field_name); va_end(ap); return (0); } /* * Return 1/0 according to whether or not * it is permissible to set the tag's value. * Note that we allow ImageLength to be changed * so that we can append and extend to images. * Any other tag may not be altered once writing * has commenced, unless its value has no effect * on the format of the data that is written. */ static int OkToChangeTag(TIFF* tif, ttag_t tag) { const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY); if (!fip) { /* unknown tag */ TIFFError("TIFFSetField", "%s: Unknown %stag %u", tif->tif_name, isPseudoTag(tag) ? "pseudo-" : "", tag); return (0); } if (tag != TIFFTAG_IMAGELENGTH && (tif->tif_flags & TIFF_BEENWRITING) && !fip->field_oktochange) { /* * Consult info table to see if tag can be changed * after we've started writing. We only allow changes * to those tags that don't/shouldn't affect the * compression and/or format of the data. */ TIFFError("TIFFSetField", "%s: Cannot modify tag \"%s\" while writing", tif->tif_name, fip->field_name); return (0); } return (1); } /* * Record the value of a field in the * internal directory structure. The * field will be written to the file * when/if the directory structure is * updated. */ int TIFFSetField(TIFF* tif, ttag_t tag, ...) { va_list ap; int status; va_start(ap, tag); status = TIFFVSetField(tif, tag, ap); va_end(ap); return (status); } /* * Like TIFFSetField, but taking a varargs * parameter list. This routine is useful * for building higher-level interfaces on * top of the library. */ int TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap) { return OkToChangeTag(tif, tag) ? (*tif->tif_vsetfield)(tif, tag, ap) : 0; } static int _TIFFVGetField(TIFF* tif, ttag_t tag, va_list ap) { TIFFDirectory* td = &tif->tif_dir; switch (tag) { case TIFFTAG_SUBFILETYPE: *va_arg(ap, uint32*) = td->td_subfiletype; break; case TIFFTAG_IMAGEWIDTH: *va_arg(ap, uint32*) = td->td_imagewidth; break; case TIFFTAG_IMAGELENGTH: *va_arg(ap, uint32*) = td->td_imagelength; break; case TIFFTAG_BITSPERSAMPLE: *va_arg(ap, uint16*) = td->td_bitspersample; break; case TIFFTAG_COMPRESSION: *va_arg(ap, uint16*) = td->td_compression; break; case TIFFTAG_PHOTOMETRIC: *va_arg(ap, uint16*) = td->td_photometric; break; case TIFFTAG_THRESHHOLDING: *va_arg(ap, uint16*) = td->td_threshholding; break; case TIFFTAG_FILLORDER: *va_arg(ap, uint16*) = td->td_fillorder; break; case TIFFTAG_DOCUMENTNAME: *va_arg(ap, char**) = td->td_documentname; break; case TIFFTAG_ARTIST: *va_arg(ap, char**) = td->td_artist; break; case TIFFTAG_DATETIME: *va_arg(ap, char**) = td->td_datetime; break; case TIFFTAG_HOSTCOMPUTER: *va_arg(ap, char**) = td->td_hostcomputer; break; case TIFFTAG_IMAGEDESCRIPTION: *va_arg(ap, char**) = td->td_imagedescription; break; case TIFFTAG_MAKE: *va_arg(ap, char**) = td->td_make; break; case TIFFTAG_MODEL: *va_arg(ap, char**) = td->td_model; break; case TIFFTAG_SOFTWARE: *va_arg(ap, char**) = td->td_software; break; case TIFFTAG_ORIENTATION: *va_arg(ap, uint16*) = td->td_orientation; break; case TIFFTAG_SAMPLESPERPIXEL: *va_arg(ap, uint16*) = td->td_samplesperpixel; break; case TIFFTAG_ROWSPERSTRIP: *va_arg(ap, uint32*) = td->td_rowsperstrip; break; case TIFFTAG_MINSAMPLEVALUE: *va_arg(ap, uint16*) = td->td_minsamplevalue; break; case TIFFTAG_MAXSAMPLEVALUE: *va_arg(ap, uint16*) = td->td_maxsamplevalue; break; case TIFFTAG_SMINSAMPLEVALUE: *va_arg(ap, double*) = td->td_sminsamplevalue; break; case TIFFTAG_SMAXSAMPLEVALUE: *va_arg(ap, double*) = td->td_smaxsamplevalue; break; case TIFFTAG_XRESOLUTION: *va_arg(ap, float*) = td->td_xresolution; break; case TIFFTAG_YRESOLUTION: *va_arg(ap, float*) = td->td_yresolution; break; case TIFFTAG_PLANARCONFIG: *va_arg(ap, uint16*) = td->td_planarconfig; break; case TIFFTAG_XPOSITION: *va_arg(ap, float*) = td->td_xposition; break; case TIFFTAG_YPOSITION: *va_arg(ap, float*) = td->td_yposition; break; case TIFFTAG_PAGENAME: *va_arg(ap, char**) = td->td_pagename; break; case TIFFTAG_RESOLUTIONUNIT: *va_arg(ap, uint16*) = td->td_resolutionunit; break; case TIFFTAG_PAGENUMBER: *va_arg(ap, uint16*) = td->td_pagenumber[0]; *va_arg(ap, uint16*) = td->td_pagenumber[1]; break; case TIFFTAG_HALFTONEHINTS: *va_arg(ap, uint16*) = td->td_halftonehints[0]; *va_arg(ap, uint16*) = td->td_halftonehints[1]; break; case TIFFTAG_COLORMAP: *va_arg(ap, uint16**) = td->td_colormap[0]; *va_arg(ap, uint16**) = td->td_colormap[1]; *va_arg(ap, uint16**) = td->td_colormap[2]; break; case TIFFTAG_STRIPOFFSETS: case TIFFTAG_TILEOFFSETS: *va_arg(ap, uint32**) = td->td_stripoffset; break; case TIFFTAG_STRIPBYTECOUNTS: case TIFFTAG_TILEBYTECOUNTS: *va_arg(ap, uint32**) = td->td_stripbytecount; break; case TIFFTAG_MATTEING: *va_arg(ap, uint16*) = (td->td_extrasamples == 1 && td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA); break; case TIFFTAG_EXTRASAMPLES: *va_arg(ap, uint16*) = td->td_extrasamples; *va_arg(ap, uint16**) = td->td_sampleinfo; break; case TIFFTAG_TILEWIDTH: *va_arg(ap, uint32*) = td->td_tilewidth; break; case TIFFTAG_TILELENGTH: *va_arg(ap, uint32*) = td->td_tilelength; break; case TIFFTAG_TILEDEPTH: *va_arg(ap, uint32*) = td->td_tiledepth; break; case TIFFTAG_DATATYPE: switch (td->td_sampleformat) { case SAMPLEFORMAT_UINT: *va_arg(ap, uint16*) = DATATYPE_UINT; break; case SAMPLEFORMAT_INT: *va_arg(ap, uint16*) = DATATYPE_INT; break; case SAMPLEFORMAT_IEEEFP: *va_arg(ap, uint16*) = DATATYPE_IEEEFP; break; case SAMPLEFORMAT_VOID: *va_arg(ap, uint16*) = DATATYPE_VOID; break; } break; case TIFFTAG_SAMPLEFORMAT: *va_arg(ap, uint16*) = td->td_sampleformat; break; case TIFFTAG_IMAGEDEPTH: *va_arg(ap, uint32*) = td->td_imagedepth; break; case TIFFTAG_STONITS: *va_arg(ap, double*) = td->td_stonits; break; #if SUBIFD_SUPPORT case TIFFTAG_SUBIFD: *va_arg(ap, uint16*) = td->td_nsubifd; *va_arg(ap, uint32**) = td->td_subifd; break; #endif #ifdef YCBCR_SUPPORT case TIFFTAG_YCBCRCOEFFICIENTS: *va_arg(ap, float**) = td->td_ycbcrcoeffs; break; case TIFFTAG_YCBCRPOSITIONING: *va_arg(ap, uint16*) = td->td_ycbcrpositioning; break; case TIFFTAG_YCBCRSUBSAMPLING: *va_arg(ap, uint16*) = td->td_ycbcrsubsampling[0]; *va_arg(ap, uint16*) = td->td_ycbcrsubsampling[1]; break; #endif #ifdef COLORIMETRY_SUPPORT case TIFFTAG_WHITEPOINT: *va_arg(ap, float**) = td->td_whitepoint; break; case TIFFTAG_PRIMARYCHROMATICITIES: *va_arg(ap, float**) = td->td_primarychromas; break; case TIFFTAG_TRANSFERFUNCTION: *va_arg(ap, uint16**) = td->td_transferfunction[0]; if (td->td_samplesperpixel - td->td_extrasamples > 1) { *va_arg(ap, uint16**) = td->td_transferfunction[1]; *va_arg(ap, uint16**) = td->td_transferfunction[2]; } break; case TIFFTAG_REFERENCEBLACKWHITE: *va_arg(ap, float**) = td->td_refblackwhite; break; #endif #ifdef CMYK_SUPPORT case TIFFTAG_INKSET: *va_arg(ap, uint16*) = td->td_inkset; break; case TIFFTAG_DOTRANGE: *va_arg(ap, uint16*) = td->td_dotrange[0]; *va_arg(ap, uint16*) = td->td_dotrange[1]; break; case TIFFTAG_INKNAMES: *va_arg(ap, char**) = td->td_inknames; break; case TIFFTAG_NUMBEROFINKS: *va_arg(ap, uint16*) = td->td_ninks; break; case TIFFTAG_TARGETPRINTER: *va_arg(ap, char**) = td->td_targetprinter; break; #endif #ifdef ICC_SUPPORT case TIFFTAG_ICCPROFILE: *va_arg(ap, uint32*) = td->td_profileLength; *va_arg(ap, void**) = td->td_profileData; break; #endif #ifdef PHOTOSHOP_SUPPORT case TIFFTAG_PHOTOSHOP: *va_arg(ap, uint32*) = td->td_photoshopLength; *va_arg(ap, void**) = td->td_photoshopData; break; #endif #ifdef IPTC_SUPPORT case TIFFTAG_RICHTIFFIPTC: *va_arg(ap, uint32*) = td->td_richtiffiptcLength; *va_arg(ap, void**) = td->td_richtiffiptcData; break; #endif /* Begin Pixar Tags */ case TIFFTAG_PIXAR_IMAGEFULLWIDTH: *va_arg(ap, uint32*) = td->td_imagefullwidth; break; case TIFFTAG_PIXAR_IMAGEFULLLENGTH: *va_arg(ap, uint32*) = td->td_imagefulllength; break; case TIFFTAG_PIXAR_TEXTUREFORMAT: *va_arg(ap, char**) = td->td_textureformat; break; case TIFFTAG_PIXAR_WRAPMODES: *va_arg(ap, char**) = td->td_wrapmodes; break; case TIFFTAG_PIXAR_FOVCOT: *va_arg(ap, float*) = td->td_fovcot; break; case TIFFTAG_PIXAR_MATRIX_WORLDTOSCREEN: *va_arg(ap, float**) = td->td_matrixWorldToScreen; break; case TIFFTAG_PIXAR_MATRIX_WORLDTOCAMERA: *va_arg(ap, float**) = td->td_matrixWorldToCamera; break; /* End Pixar Tags */ default: /* * This can happen if multiple images are open with * different codecs which have private tags. The * global tag information table may then have tags * that are valid for one file but not the other. * If the client tries to get a tag that is not valid * for the image's codec then we'll arrive here. */ TIFFError("TIFFGetField", "%s: Invalid %stag \"%s\" (not supported by codec)", tif->tif_name, isPseudoTag(tag) ? "pseudo-" : "", _TIFFFieldWithTag(tif, tag)->field_name); break; } return (1); } /* * Return the value of a field in the * internal directory structure. */ int TIFFGetField(TIFF* tif, ttag_t tag, ...) { int status; va_list ap; va_start(ap, tag); status = TIFFVGetField(tif, tag, ap); va_end(ap); return (status); } /* * Like TIFFGetField, but taking a varargs * parameter list. This routine is useful * for building higher-level interfaces on * top of the library. */ int TIFFVGetField(TIFF* tif, ttag_t tag, va_list ap) { const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY); return (fip && (isPseudoTag(tag) || TIFFFieldSet(tif, fip->field_bit)) ? (*tif->tif_vgetfield)(tif, tag, ap) : 0); } #define CleanupField(member) { \ if (td->member) { \ _TIFFfree(td->member); \ td->member = 0; \ } \ } /* * Release storage associated with a directory. */ void TIFFFreeDirectory(TIFF* tif) { register TIFFDirectory *td = &tif->tif_dir; CleanupField(td_colormap[0]); CleanupField(td_colormap[1]); CleanupField(td_colormap[2]); CleanupField(td_documentname); CleanupField(td_artist); CleanupField(td_datetime); CleanupField(td_hostcomputer); CleanupField(td_imagedescription); CleanupField(td_make); CleanupField(td_model); CleanupField(td_software); CleanupField(td_pagename); CleanupField(td_sampleinfo); #if SUBIFD_SUPPORT CleanupField(td_subifd); #endif #ifdef YCBCR_SUPPORT CleanupField(td_ycbcrcoeffs); #endif #ifdef CMYK_SUPPORT CleanupField(td_inknames); CleanupField(td_targetprinter); #endif #ifdef COLORIMETRY_SUPPORT CleanupField(td_whitepoint); CleanupField(td_primarychromas); CleanupField(td_refblackwhite); CleanupField(td_transferfunction[0]); CleanupField(td_transferfunction[1]); CleanupField(td_transferfunction[2]); #endif #ifdef ICC_SUPPORT CleanupField(td_profileData); #endif #ifdef PHOTOSHOP_SUPPORT CleanupField(td_photoshopData); #endif #ifdef IPTC_SUPPORT CleanupField(td_richtiffiptcData); #endif CleanupField(td_stripoffset); CleanupField(td_stripbytecount); /* Begin Pixar Tags */ CleanupField(td_textureformat); CleanupField(td_wrapmodes); CleanupField(td_matrixWorldToScreen); CleanupField(td_matrixWorldToCamera); /* End Pixar Tags */ } #undef CleanupField /* * Client Tag extension support (from Niles Ritter). */ static TIFFExtendProc _TIFFextender = (TIFFExtendProc) NULL; TIFFExtendProc TIFFSetTagExtender(TIFFExtendProc extender) { TIFFExtendProc prev = _TIFFextender; _TIFFextender = extender; return (prev); } /* * Setup a default directory structure. */ int TIFFDefaultDirectory(TIFF* tif) { register TIFFDirectory* td = &tif->tif_dir; _TIFFSetupFieldInfo(tif); _TIFFmemset(td, 0, sizeof (*td)); td->td_fillorder = FILLORDER_MSB2LSB; td->td_bitspersample = 1; td->td_threshholding = THRESHHOLD_BILEVEL; td->td_orientation = ORIENTATION_TOPLEFT; td->td_samplesperpixel = 1; td->td_rowsperstrip = (uint32) -1; td->td_tilewidth = (uint32) -1; td->td_tilelength = (uint32) -1; td->td_tiledepth = 1; td->td_resolutionunit = RESUNIT_INCH; td->td_sampleformat = SAMPLEFORMAT_VOID; td->td_imagedepth = 1; #ifdef YCBCR_SUPPORT td->td_ycbcrsubsampling[0] = 2; td->td_ycbcrsubsampling[1] = 2; td->td_ycbcrpositioning = YCBCRPOSITION_CENTERED; #endif #ifdef CMYK_SUPPORT td->td_inkset = INKSET_CMYK; td->td_ninks = 4; #endif tif->tif_postdecode = _TIFFNoPostDecode; tif->tif_vsetfield = _TIFFVSetField; tif->tif_vgetfield = _TIFFVGetField; tif->tif_printdir = NULL; /* * Give client code a chance to install their own * tag extensions & methods, prior to compression overloads. */ if (_TIFFextender) (*_TIFFextender)(tif); (void) TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE); /* * NB: The directory is marked dirty as a result of setting * up the default compression scheme. However, this really * isn't correct -- we want TIFF_DIRTYDIRECT to be set only * if the user does something. We could just do the setup * by hand, but it seems better to use the normal mechanism * (i.e. TIFFSetField). */ tif->tif_flags &= ~TIFF_DIRTYDIRECT; return (1); } static int TIFFAdvanceDirectory(TIFF* tif, uint32* nextdir, toff_t* off) { static const char module[] = "TIFFAdvanceDirectory"; uint16 dircount; if (isMapped(tif)) { tsize_t poff=*nextdir; if (((tsize_t) (poff+sizeof(uint16))) > tif->tif_size) { TIFFError(module, "%s: Error fetching directory count", tif->tif_name); return (0); } _TIFFmemcpy(&dircount, tif->tif_base+poff, sizeof (uint16)); if (tif->tif_flags & TIFF_SWAB) TIFFSwabShort(&dircount); poff+=sizeof (uint16)+dircount*sizeof (TIFFDirEntry); if (off != NULL) *off = poff; if (((tsize_t) (poff+sizeof (uint32))) > tif->tif_size) { TIFFError(module, "%s: Error fetching directory link", tif->tif_name); return (0); } _TIFFmemcpy(nextdir, tif->tif_base+poff, sizeof (uint32)); if (tif->tif_flags & TIFF_SWAB) TIFFSwabLong(nextdir); return (1); } else { if (!SeekOK(tif, *nextdir) || !ReadOK(tif, &dircount, sizeof (uint16))) { TIFFError(module, "%s: Error fetching directory count", tif->tif_name); return (0); } if (tif->tif_flags & TIFF_SWAB) TIFFSwabShort(&dircount); if (off != NULL) *off = TIFFSeekFile(tif, dircount*sizeof (TIFFDirEntry), SEEK_CUR); else (void) TIFFSeekFile(tif, dircount*sizeof (TIFFDirEntry), SEEK_CUR); if (!ReadOK(tif, nextdir, sizeof (uint32))) { TIFFError(module, "%s: Error fetching directory link", tif->tif_name); return (0); } if (tif->tif_flags & TIFF_SWAB) TIFFSwabLong(nextdir); return (1); } } /* * Count the number of directories in a file. */ tdir_t TIFFNumberOfDirectories(TIFF* tif) { uint32 nextdir = tif->tif_header.tiff_diroff; tdir_t n = 0; while (nextdir != 0 && TIFFAdvanceDirectory(tif, &nextdir, NULL)) n++; return (n); } /* * Set the n-th directory as the current directory. * NB: Directories are numbered starting at 0. */ int TIFFSetDirectory(TIFF* tif, tdir_t dirn) { uint32 nextdir; tdir_t n; nextdir = tif->tif_header.tiff_diroff; for (n = dirn; n > 0 && nextdir != 0; n--) if (!TIFFAdvanceDirectory(tif, &nextdir, NULL)) return (0); tif->tif_nextdiroff = nextdir; /* * Set curdir to the actual directory index. The * -1 is because TIFFReadDirectory will increment * tif_curdir after successfully reading the directory. */ tif->tif_curdir = (dirn - n) - 1; return (TIFFReadDirectory(tif)); } /* * Set the current directory to be the directory * located at the specified file offset. This interface * is used mainly to access directories linked with * the SubIFD tag (e.g. thumbnail images). */ int TIFFSetSubDirectory(TIFF* tif, uint32 diroff) { tif->tif_nextdiroff = diroff; return (TIFFReadDirectory(tif)); } /* * Return file offset of the current directory. */ uint32 TIFFCurrentDirOffset(TIFF* tif) { return (tif->tif_diroff); } /* * Return an indication of whether or not we are * at the last directory in the file. */ int TIFFLastDirectory(TIFF* tif) { return (tif->tif_nextdiroff == 0); } /* * Unlink the specified directory from the directory chain. */ int TIFFUnlinkDirectory(TIFF* tif, tdir_t dirn) { static const char module[] = "TIFFUnlinkDirectory"; uint32 nextdir; toff_t off; tdir_t n; if (tif->tif_mode == O_RDONLY) { TIFFError(module, "Can not unlink directory in read-only file"); return (0); } /* * Go to the directory before the one we want * to unlink and nab the offset of the link * field we'll need to patch. */ nextdir = tif->tif_header.tiff_diroff; off = sizeof (uint16) + sizeof (uint16); for (n = dirn-1; n > 0; n--) { if (nextdir == 0) { TIFFError(module, "Directory %d does not exist", dirn); return (0); } if (!TIFFAdvanceDirectory(tif, &nextdir, &off)) return (0); } /* * Advance to the directory to be unlinked and fetch * the offset of the directory that follows. */ if (!TIFFAdvanceDirectory(tif, &nextdir, NULL)) return (0); /* * Go back and patch the link field of the preceding * directory to point to the offset of the directory * that follows. */ (void) TIFFSeekFile(tif, off, SEEK_SET); if (tif->tif_flags & TIFF_SWAB) TIFFSwabLong(&nextdir); if (!WriteOK(tif, &nextdir, sizeof (uint32))) { TIFFError(module, "Error writing directory link"); return (0); } /* * Leave directory state setup safely. We don't have * facilities for doing inserting and removing directories, * so it's safest to just invalidate everything. This * means that the caller can only append to the directory * chain. */ (*tif->tif_cleanup)(tif); if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) { _TIFFfree(tif->tif_rawdata); tif->tif_rawdata = NULL; tif->tif_rawcc = 0; } tif->tif_flags &= ~(TIFF_BEENWRITING|TIFF_BUFFERSETUP|TIFF_POSTENCODE); TIFFFreeDirectory(tif); TIFFDefaultDirectory(tif); tif->tif_diroff = 0; /* force link on next write */ tif->tif_nextdiroff = 0; /* next write must be at end */ tif->tif_curoff = 0; tif->tif_row = (uint32) -1; tif->tif_curstrip = (tstrip_t) -1; return (1); } /* [BFC] * * Author: Bruce Cameron * * Set a table of tags that are to be replaced during directory process by the * 'IGNORE' state - or return TRUE/FALSE for the requested tag such that * 'ReadDirectory' can use the stored information. */ int TIFFReassignTagToIgnore (enum TIFFIgnoreSense task, int TIFFtagID) { static int TIFFignoretags [FIELD_LAST]; static int tagcount = 0 ; int i; /* Loop index */ int j; /* Loop index */ switch (task) { case TIS_STORE: if ( tagcount < (FIELD_LAST - 1) ) { for ( j = 0 ; j < tagcount ; ++j ) { /* Do not add duplicate tag */ if ( TIFFignoretags [j] == TIFFtagID ) return (TRUE) ; } TIFFignoretags [tagcount++] = TIFFtagID ; return (TRUE) ; } break ; case TIS_EXTRACT: for ( i = 0 ; i < tagcount ; ++i ) { if ( TIFFignoretags [i] == TIFFtagID ) return (TRUE) ; } break; case TIS_EMPTY: tagcount = 0 ; /* Clear the list */ return (TRUE) ; break; default: break; } return (FALSE); } netpbm-8.2/libtiff/tif_dir.h0100660000076400000000000002121107027731307015101 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_dir.h,v 1.2 1999/12/21 17:03:03 mwelles Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #ifndef _TIFFDIR_ #define _TIFFDIR_ /* * ``Library-private'' Directory-related Definitions. */ /* * Internal format of a TIFF directory entry. */ typedef struct { #define FIELD_SETLONGS 3 /* bit vector of fields that are set */ u_long td_fieldsset[FIELD_SETLONGS]; uint32 td_imagewidth, td_imagelength, td_imagedepth; uint32 td_tilewidth, td_tilelength, td_tiledepth; uint32 td_subfiletype; uint16 td_bitspersample; uint16 td_sampleformat; uint16 td_compression; uint16 td_photometric; uint16 td_threshholding; uint16 td_fillorder; uint16 td_orientation; uint16 td_samplesperpixel; uint32 td_rowsperstrip; uint16 td_minsamplevalue, td_maxsamplevalue; double td_sminsamplevalue, td_smaxsamplevalue; float td_xresolution, td_yresolution; uint16 td_resolutionunit; uint16 td_planarconfig; float td_xposition, td_yposition; uint16 td_pagenumber[2]; uint16* td_colormap[3]; uint16 td_halftonehints[2]; uint16 td_extrasamples; uint16* td_sampleinfo; double td_stonits; char* td_documentname; char* td_artist; char* td_datetime; char* td_hostcomputer; char* td_imagedescription; char* td_make; char* td_model; char* td_software; char* td_pagename; tstrip_t td_stripsperimage; tstrip_t td_nstrips; /* size of offset & bytecount arrays */ uint32* td_stripoffset; uint32* td_stripbytecount; #if SUBIFD_SUPPORT uint16 td_nsubifd; uint32* td_subifd; #endif #ifdef YCBCR_SUPPORT float* td_ycbcrcoeffs; uint16 td_ycbcrsubsampling[2]; uint16 td_ycbcrpositioning; #endif #ifdef COLORIMETRY_SUPPORT float* td_whitepoint; float* td_primarychromas; float* td_refblackwhite; uint16* td_transferfunction[3]; #endif #ifdef CMYK_SUPPORT uint16 td_inkset; uint16 td_ninks; uint16 td_dotrange[2]; int td_inknameslen; char* td_inknames; char* td_targetprinter; #endif #ifdef ICC_SUPPORT uint32 td_profileLength; void *td_profileData; #endif #ifdef PHOTOSHOP_SUPPORT uint32 td_photoshopLength; void *td_photoshopData; #endif #ifdef IPTC_SUPPORT uint32 td_richtiffiptcLength; void *td_richtiffiptcData; #endif /* Begin Pixar Tag values. */ uint32 td_imagefullwidth, td_imagefulllength; char* td_textureformat; char* td_wrapmodes; float td_fovcot; float* td_matrixWorldToScreen; float* td_matrixWorldToCamera; /* End Pixar Tag Values. */ } TIFFDirectory; /* * Field flags used to indicate fields that have * been set in a directory, and to reference fields * when manipulating a directory. */ /* * FIELD_IGNORE is used to signify tags that are to * be processed but otherwise ignored. This permits * antiquated tags to be quietly read and discarded. * Note that a bit *is* allocated for ignored tags; * this is understood by the directory reading logic * which uses this fact to avoid special-case handling */ #define FIELD_IGNORE 0 /* multi-item fields */ #define FIELD_IMAGEDIMENSIONS 1 #define FIELD_TILEDIMENSIONS 2 #define FIELD_RESOLUTION 3 #define FIELD_POSITION 4 /* single-item fields */ #define FIELD_SUBFILETYPE 5 #define FIELD_BITSPERSAMPLE 6 #define FIELD_COMPRESSION 7 #define FIELD_PHOTOMETRIC 8 #define FIELD_THRESHHOLDING 9 #define FIELD_FILLORDER 10 #define FIELD_DOCUMENTNAME 11 #define FIELD_IMAGEDESCRIPTION 12 #define FIELD_MAKE 13 #define FIELD_MODEL 14 #define FIELD_ORIENTATION 15 #define FIELD_SAMPLESPERPIXEL 16 #define FIELD_ROWSPERSTRIP 17 #define FIELD_MINSAMPLEVALUE 18 #define FIELD_MAXSAMPLEVALUE 19 #define FIELD_PLANARCONFIG 20 #define FIELD_PAGENAME 21 #define FIELD_RESOLUTIONUNIT 22 #define FIELD_PAGENUMBER 23 #define FIELD_STRIPBYTECOUNTS 24 #define FIELD_STRIPOFFSETS 25 #define FIELD_COLORMAP 26 #define FIELD_ARTIST 27 #define FIELD_DATETIME 28 #define FIELD_HOSTCOMPUTER 29 #define FIELD_SOFTWARE 30 #define FIELD_EXTRASAMPLES 31 #define FIELD_SAMPLEFORMAT 32 #define FIELD_SMINSAMPLEVALUE 33 #define FIELD_SMAXSAMPLEVALUE 34 #define FIELD_IMAGEDEPTH 35 #define FIELD_TILEDEPTH 36 #define FIELD_HALFTONEHINTS 37 #define FIELD_YCBCRCOEFFICIENTS 38 #define FIELD_YCBCRSUBSAMPLING 39 #define FIELD_YCBCRPOSITIONING 40 #define FIELD_REFBLACKWHITE 41 #define FIELD_WHITEPOINT 42 #define FIELD_PRIMARYCHROMAS 43 #define FIELD_TRANSFERFUNCTION 44 #define FIELD_INKSET 45 #define FIELD_INKNAMES 46 #define FIELD_DOTRANGE 47 #define FIELD_TARGETPRINTER 48 #define FIELD_SUBIFD 49 #define FIELD_NUMBEROFINKS 50 #define FIELD_ICCPROFILE 51 #define FIELD_PHOTOSHOP 52 #define FIELD_RICHTIFFIPTC 53 #define FIELD_STONITS 54 /* Begin PIXAR */ #define FIELD_IMAGEFULLWIDTH 55 #define FIELD_IMAGEFULLLENGTH 56 #define FIELD_TEXTUREFORMAT 57 #define FIELD_WRAPMODES 58 #define FIELD_FOVCOT 59 #define FIELD_MATRIX_WORLDTOSCREEN 60 #define FIELD_MATRIX_WORLDTOCAMERA 61 /* end of support for well-known tags; codec-private tags follow */ #define FIELD_CODEC 62 /* base of codec-private tags */ /* * Pseudo-tags don't normally need field bits since they * are not written to an output file (by definition). * The library also has express logic to always query a * codec for a pseudo-tag so allocating a field bit for * one is a waste. If codec wants to promote the notion * of a pseudo-tag being ``set'' or ``unset'' then it can * do using internal state flags without polluting the * field bit space defined for real tags. */ #define FIELD_PSEUDO 0 #define FIELD_LAST (32*FIELD_SETLONGS-1) #define TIFFExtractData(tif, type, v) \ ((uint32) ((tif)->tif_header.tiff_magic == TIFF_BIGENDIAN ? \ ((v) >> (tif)->tif_typeshift[type]) & (tif)->tif_typemask[type] : \ (v) & (tif)->tif_typemask[type])) #define TIFFInsertData(tif, type, v) \ ((uint32) ((tif)->tif_header.tiff_magic == TIFF_BIGENDIAN ? \ ((v) & (tif)->tif_typemask[type]) << (tif)->tif_typeshift[type] : \ (v) & (tif)->tif_typemask[type])) 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 */ u_short field_bit; /* bit in fieldsset bit vector */ u_char field_oktochange; /* if true, can change while writing */ u_char field_passcount; /* if true, pass dir count on set */ char *field_name; /* ASCII name */ } TIFFFieldInfo; #define TIFF_ANY TIFF_NOTYPE /* for field descriptor searching */ #define TIFF_VARIABLE -1 /* marker for variable length tags */ #define TIFF_SPP -2 /* marker for SamplesPerPixel tags */ #define TIFF_VARIABLE2 -3 /* marker for uint32 var-length tags */ extern const int tiffDataWidth[]; /* table of tag datatype widths */ #define BITn(n) (((u_long)1L)<<((n)&0x1f)) #define BITFIELDn(tif, n) ((tif)->tif_dir.td_fieldsset[(n)/32]) #define TIFFFieldSet(tif, field) (BITFIELDn(tif, field) & BITn(field)) #define TIFFSetFieldBit(tif, field) (BITFIELDn(tif, field) |= BITn(field)) #define TIFFClrFieldBit(tif, field) (BITFIELDn(tif, field) &= ~BITn(field)) #define FieldSet(fields, f) (fields[(f)/32] & BITn(f)) #define ResetFieldBit(fields, f) (fields[(f)/32] &= ~BITn(f)) #if defined(__cplusplus) extern "C" { #endif extern void _TIFFSetupFieldInfo(TIFF*); extern void _TIFFMergeFieldInfo(TIFF*, const TIFFFieldInfo[], int); extern void _TIFFPrintFieldInfo(TIFF*, FILE*); extern const TIFFFieldInfo* _TIFFFindFieldInfo(TIFF*, ttag_t, TIFFDataType); extern const TIFFFieldInfo* _TIFFFieldWithTag(TIFF*, ttag_t); extern TIFFDataType _TIFFSampleToTagType(TIFF*); #if defined(__cplusplus) } #endif #endif /* _TIFFDIR_ */ netpbm-8.2/libtiff/tif_dirinfo.c0100660000076400000000000003646607027731307015772 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_dirinfo.c,v 1.2 1999/12/21 17:03:03 mwelles Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library. * * Core Directory Tag Support. */ #include "tiffiop.h" #include /* * NB: NB: THIS ARRAY IS ASSUMED TO BE SORTED BY TAG. * If a tag can have both LONG and SHORT types * then the LONG must be placed before the SHORT for * writing to work properly. */ static const TIFFFieldInfo tiffFieldInfo[] = { { TIFFTAG_SUBFILETYPE, 1, 1, TIFF_LONG, FIELD_SUBFILETYPE, TRUE, FALSE, "SubfileType" }, /* XXX SHORT for compatibility w/ old versions of the library */ { TIFFTAG_SUBFILETYPE, 1, 1, TIFF_SHORT, FIELD_SUBFILETYPE, TRUE, FALSE, "SubfileType" }, { TIFFTAG_OSUBFILETYPE, 1, 1, TIFF_SHORT, FIELD_SUBFILETYPE, TRUE, FALSE, "OldSubfileType" }, { TIFFTAG_IMAGEWIDTH, 1, 1, TIFF_LONG, FIELD_IMAGEDIMENSIONS, FALSE, FALSE, "ImageWidth" }, { TIFFTAG_IMAGEWIDTH, 1, 1, TIFF_SHORT, FIELD_IMAGEDIMENSIONS, FALSE, FALSE, "ImageWidth" }, { TIFFTAG_IMAGELENGTH, 1, 1, TIFF_LONG, FIELD_IMAGEDIMENSIONS, TRUE, FALSE, "ImageLength" }, { TIFFTAG_IMAGELENGTH, 1, 1, TIFF_SHORT, FIELD_IMAGEDIMENSIONS, TRUE, FALSE, "ImageLength" }, { TIFFTAG_BITSPERSAMPLE, -1,-1, TIFF_SHORT, FIELD_BITSPERSAMPLE, FALSE, FALSE, "BitsPerSample" }, { TIFFTAG_COMPRESSION, -1, 1, TIFF_SHORT, FIELD_COMPRESSION, FALSE, FALSE, "Compression" }, { TIFFTAG_PHOTOMETRIC, 1, 1, TIFF_SHORT, FIELD_PHOTOMETRIC, FALSE, FALSE, "PhotometricInterpretation" }, { TIFFTAG_THRESHHOLDING, 1, 1, TIFF_SHORT, FIELD_THRESHHOLDING, TRUE, FALSE, "Threshholding" }, { TIFFTAG_CELLWIDTH, 1, 1, TIFF_SHORT, FIELD_IGNORE, TRUE, FALSE, "CellWidth" }, { TIFFTAG_CELLLENGTH, 1, 1, TIFF_SHORT, FIELD_IGNORE, TRUE, FALSE, "CellLength" }, { TIFFTAG_FILLORDER, 1, 1, TIFF_SHORT, FIELD_FILLORDER, FALSE, FALSE, "FillOrder" }, { TIFFTAG_DOCUMENTNAME, -1,-1, TIFF_ASCII, FIELD_DOCUMENTNAME, TRUE, FALSE, "DocumentName" }, { TIFFTAG_IMAGEDESCRIPTION, -1,-1, TIFF_ASCII, FIELD_IMAGEDESCRIPTION, TRUE, FALSE, "ImageDescription" }, { TIFFTAG_MAKE, -1,-1, TIFF_ASCII, FIELD_MAKE, TRUE, FALSE, "Make" }, { TIFFTAG_MODEL, -1,-1, TIFF_ASCII, FIELD_MODEL, TRUE, FALSE, "Model" }, { TIFFTAG_STRIPOFFSETS, -1,-1, TIFF_LONG, FIELD_STRIPOFFSETS, FALSE, FALSE, "StripOffsets" }, { TIFFTAG_STRIPOFFSETS, -1,-1, TIFF_SHORT, FIELD_STRIPOFFSETS, FALSE, FALSE, "StripOffsets" }, { TIFFTAG_ORIENTATION, 1, 1, TIFF_SHORT, FIELD_ORIENTATION, FALSE, FALSE, "Orientation" }, { TIFFTAG_SAMPLESPERPIXEL, 1, 1, TIFF_SHORT, FIELD_SAMPLESPERPIXEL, FALSE, FALSE, "SamplesPerPixel" }, { TIFFTAG_ROWSPERSTRIP, 1, 1, TIFF_LONG, FIELD_ROWSPERSTRIP, FALSE, FALSE, "RowsPerStrip" }, { TIFFTAG_ROWSPERSTRIP, 1, 1, TIFF_SHORT, FIELD_ROWSPERSTRIP, FALSE, FALSE, "RowsPerStrip" }, { TIFFTAG_STRIPBYTECOUNTS, -1,-1, TIFF_LONG, FIELD_STRIPBYTECOUNTS, FALSE, FALSE, "StripByteCounts" }, { TIFFTAG_STRIPBYTECOUNTS, -1,-1, TIFF_SHORT, FIELD_STRIPBYTECOUNTS, FALSE, FALSE, "StripByteCounts" }, { TIFFTAG_MINSAMPLEVALUE, -2,-1, TIFF_SHORT, FIELD_MINSAMPLEVALUE, TRUE, FALSE, "MinSampleValue" }, { TIFFTAG_MAXSAMPLEVALUE, -2,-1, TIFF_SHORT, FIELD_MAXSAMPLEVALUE, TRUE, FALSE, "MaxSampleValue" }, { TIFFTAG_XRESOLUTION, 1, 1, TIFF_RATIONAL, FIELD_RESOLUTION, FALSE, FALSE, "XResolution" }, { TIFFTAG_YRESOLUTION, 1, 1, TIFF_RATIONAL, FIELD_RESOLUTION, FALSE, FALSE, "YResolution" }, { TIFFTAG_PLANARCONFIG, 1, 1, TIFF_SHORT, FIELD_PLANARCONFIG, FALSE, FALSE, "PlanarConfiguration" }, { TIFFTAG_PAGENAME, -1,-1, TIFF_ASCII, FIELD_PAGENAME, TRUE, FALSE, "PageName" }, { TIFFTAG_XPOSITION, 1, 1, TIFF_RATIONAL, FIELD_POSITION, TRUE, FALSE, "XPosition" }, { TIFFTAG_YPOSITION, 1, 1, TIFF_RATIONAL, FIELD_POSITION, TRUE, FALSE, "YPosition" }, { TIFFTAG_FREEOFFSETS, -1,-1, TIFF_LONG, FIELD_IGNORE, FALSE, FALSE, "FreeOffsets" }, { TIFFTAG_FREEBYTECOUNTS, -1,-1, TIFF_LONG, FIELD_IGNORE, FALSE, FALSE, "FreeByteCounts" }, { TIFFTAG_GRAYRESPONSEUNIT, 1, 1, TIFF_SHORT, FIELD_IGNORE, TRUE, FALSE, "GrayResponseUnit" }, { TIFFTAG_GRAYRESPONSECURVE,-1,-1, TIFF_SHORT, FIELD_IGNORE, TRUE, FALSE, "GrayResponseCurve" }, { TIFFTAG_RESOLUTIONUNIT, 1, 1, TIFF_SHORT, FIELD_RESOLUTIONUNIT, FALSE, FALSE, "ResolutionUnit" }, { TIFFTAG_PAGENUMBER, 2, 2, TIFF_SHORT, FIELD_PAGENUMBER, TRUE, FALSE, "PageNumber" }, { TIFFTAG_COLORRESPONSEUNIT, 1, 1, TIFF_SHORT, FIELD_IGNORE, TRUE, FALSE, "ColorResponseUnit" }, #ifdef COLORIMETRY_SUPPORT { TIFFTAG_TRANSFERFUNCTION, -1,-1, TIFF_SHORT, FIELD_TRANSFERFUNCTION, TRUE, FALSE, "TransferFunction" }, #endif { TIFFTAG_SOFTWARE, -1,-1, TIFF_ASCII, FIELD_SOFTWARE, TRUE, FALSE, "Software" }, { TIFFTAG_DATETIME, 20,20, TIFF_ASCII, FIELD_DATETIME, TRUE, FALSE, "DateTime" }, { TIFFTAG_ARTIST, -1,-1, TIFF_ASCII, FIELD_ARTIST, TRUE, FALSE, "Artist" }, { TIFFTAG_HOSTCOMPUTER, -1,-1, TIFF_ASCII, FIELD_HOSTCOMPUTER, TRUE, FALSE, "HostComputer" }, #ifdef COLORIMETRY_SUPPORT { TIFFTAG_WHITEPOINT, 2, 2, TIFF_RATIONAL,FIELD_WHITEPOINT, TRUE, FALSE, "WhitePoint" }, { TIFFTAG_PRIMARYCHROMATICITIES,6,6,TIFF_RATIONAL,FIELD_PRIMARYCHROMAS, TRUE, FALSE, "PrimaryChromaticities" }, #endif { TIFFTAG_COLORMAP, -1,-1, TIFF_SHORT, FIELD_COLORMAP, TRUE, FALSE, "ColorMap" }, { TIFFTAG_HALFTONEHINTS, 2, 2, TIFF_SHORT, FIELD_HALFTONEHINTS, TRUE, FALSE, "HalftoneHints" }, { TIFFTAG_TILEWIDTH, 1, 1, TIFF_LONG, FIELD_TILEDIMENSIONS, FALSE, FALSE, "TileWidth" }, { TIFFTAG_TILEWIDTH, 1, 1, TIFF_SHORT, FIELD_TILEDIMENSIONS, FALSE, FALSE, "TileWidth" }, { TIFFTAG_TILELENGTH, 1, 1, TIFF_LONG, FIELD_TILEDIMENSIONS, FALSE, FALSE, "TileLength" }, { TIFFTAG_TILELENGTH, 1, 1, TIFF_SHORT, FIELD_TILEDIMENSIONS, FALSE, FALSE, "TileLength" }, { TIFFTAG_TILEOFFSETS, -1, 1, TIFF_LONG, FIELD_STRIPOFFSETS, FALSE, FALSE, "TileOffsets" }, { TIFFTAG_TILEBYTECOUNTS, -1, 1, TIFF_LONG, FIELD_STRIPBYTECOUNTS, FALSE, FALSE, "TileByteCounts" }, { TIFFTAG_TILEBYTECOUNTS, -1, 1, TIFF_SHORT, FIELD_STRIPBYTECOUNTS, FALSE, FALSE, "TileByteCounts" }, #ifdef TIFFTAG_SUBIFD { TIFFTAG_SUBIFD, -1,-1, TIFF_LONG, FIELD_SUBIFD, TRUE, TRUE, "SubIFD" }, #endif #ifdef CMYK_SUPPORT /* 6.0 CMYK tags */ { TIFFTAG_INKSET, 1, 1, TIFF_SHORT, FIELD_INKSET, FALSE, FALSE, "InkSet" }, { TIFFTAG_INKNAMES, -1,-1, TIFF_ASCII, FIELD_INKNAMES, TRUE, TRUE, "InkNames" }, { TIFFTAG_NUMBEROFINKS, 1, 1, TIFF_SHORT, FIELD_NUMBEROFINKS, TRUE, FALSE, "NumberOfInks" }, { TIFFTAG_DOTRANGE, 2, 2, TIFF_SHORT, FIELD_DOTRANGE, FALSE, FALSE, "DotRange" }, { TIFFTAG_DOTRANGE, 2, 2, TIFF_BYTE, FIELD_DOTRANGE, FALSE, FALSE, "DotRange" }, { TIFFTAG_TARGETPRINTER, -1,-1, TIFF_ASCII, FIELD_TARGETPRINTER, TRUE, FALSE, "TargetPrinter" }, #endif { TIFFTAG_EXTRASAMPLES, -1,-1, TIFF_SHORT, FIELD_EXTRASAMPLES, FALSE, FALSE, "ExtraSamples" }, /* XXX for bogus Adobe Photoshop v2.5 files */ { TIFFTAG_EXTRASAMPLES, -1,-1, TIFF_BYTE, FIELD_EXTRASAMPLES, FALSE, FALSE, "ExtraSamples" }, { TIFFTAG_SAMPLEFORMAT, -1,-1, TIFF_SHORT, FIELD_SAMPLEFORMAT, FALSE, FALSE, "SampleFormat" }, { TIFFTAG_SMINSAMPLEVALUE, -2,-1, TIFF_ANY, FIELD_SMINSAMPLEVALUE, TRUE, FALSE, "SMinSampleValue" }, { TIFFTAG_SMAXSAMPLEVALUE, -2,-1, TIFF_ANY, FIELD_SMAXSAMPLEVALUE, TRUE, FALSE, "SMaxSampleValue" }, #ifdef YCBCR_SUPPORT /* 6.0 YCbCr tags */ { TIFFTAG_YCBCRCOEFFICIENTS, 3, 3, TIFF_RATIONAL, FIELD_YCBCRCOEFFICIENTS, FALSE, FALSE, "YCbCrCoefficients" }, { TIFFTAG_YCBCRSUBSAMPLING, 2, 2, TIFF_SHORT, FIELD_YCBCRSUBSAMPLING, FALSE, FALSE, "YCbCrSubsampling" }, { TIFFTAG_YCBCRPOSITIONING, 1, 1, TIFF_SHORT, FIELD_YCBCRPOSITIONING, FALSE, FALSE, "YCbCrPositioning" }, #endif #ifdef COLORIMETRY_SUPPORT { TIFFTAG_REFERENCEBLACKWHITE,6,6,TIFF_RATIONAL, FIELD_REFBLACKWHITE, TRUE, FALSE, "ReferenceBlackWhite" }, /* XXX temporarily accept LONG for backwards compatibility */ { TIFFTAG_REFERENCEBLACKWHITE,6,6,TIFF_LONG, FIELD_REFBLACKWHITE, TRUE, FALSE, "ReferenceBlackWhite" }, #endif /* begin SGI tags */ { TIFFTAG_MATTEING, 1, 1, TIFF_SHORT, FIELD_EXTRASAMPLES, FALSE, FALSE, "Matteing" }, { TIFFTAG_DATATYPE, -2,-1, TIFF_SHORT, FIELD_SAMPLEFORMAT, FALSE, FALSE, "DataType" }, { TIFFTAG_IMAGEDEPTH, 1, 1, TIFF_LONG, FIELD_IMAGEDEPTH, FALSE, FALSE, "ImageDepth" }, { TIFFTAG_IMAGEDEPTH, 1, 1, TIFF_SHORT, FIELD_IMAGEDEPTH, FALSE, FALSE, "ImageDepth" }, { TIFFTAG_TILEDEPTH, 1, 1, TIFF_LONG, FIELD_TILEDEPTH, FALSE, FALSE, "TileDepth" }, { TIFFTAG_TILEDEPTH, 1, 1, TIFF_SHORT, FIELD_TILEDEPTH, FALSE, FALSE, "TileDepth" }, /* end SGI tags */ #ifdef IPTC_SUPPORT #ifdef PHOTOSHOP_SUPPORT { TIFFTAG_RICHTIFFIPTC, -1,-1, TIFF_LONG, FIELD_RICHTIFFIPTC, FALSE, TRUE, "RichTIFFIPTC" }, #else { TIFFTAG_RICHTIFFIPTC, -1,-3, TIFF_UNDEFINED, FIELD_RICHTIFFIPTC, FALSE, TRUE, "RichTIFFIPTC" }, #endif #endif #ifdef PHOTOSHOP_SUPPORT { TIFFTAG_PHOTOSHOP, -1,-3, TIFF_UNDEFINED, FIELD_PHOTOSHOP, FALSE, TRUE, "Photoshop" }, { TIFFTAG_PHOTOSHOP, -1,-1, TIFF_BYTE, FIELD_PHOTOSHOP, FALSE, TRUE, "Photoshop" }, #endif #ifdef ICC_SUPPORT { TIFFTAG_ICCPROFILE, -1,-3, TIFF_UNDEFINED, FIELD_ICCPROFILE, FALSE, TRUE, "ICC Profile" }, #endif { TIFFTAG_STONITS, 1, 1, TIFF_DOUBLE, FIELD_STONITS, FALSE, FALSE, "StoNits" }, /* begin Pixar tags */ { TIFFTAG_PIXAR_IMAGEFULLWIDTH, 1, 1, TIFF_LONG, FIELD_IMAGEFULLWIDTH, TRUE, FALSE, "ImageFullWidth" }, { TIFFTAG_PIXAR_IMAGEFULLLENGTH, 1, 1, TIFF_LONG, FIELD_IMAGEFULLLENGTH, TRUE, FALSE, "ImageFullLength" }, { TIFFTAG_PIXAR_TEXTUREFORMAT, -1,-1, TIFF_ASCII, FIELD_TEXTUREFORMAT, TRUE, FALSE, "TextureFormat" }, { TIFFTAG_PIXAR_WRAPMODES, -1,-1, TIFF_ASCII, FIELD_WRAPMODES, TRUE, FALSE, "TextureWrapModes" }, { TIFFTAG_PIXAR_FOVCOT, 1, 1, TIFF_FLOAT, FIELD_FOVCOT, TRUE, FALSE, "FieldOfViewCotan" }, { TIFFTAG_PIXAR_MATRIX_WORLDTOSCREEN, 16,16, TIFF_FLOAT, FIELD_MATRIX_WORLDTOSCREEN, TRUE, FALSE, "MatrixWorldToScreen" }, { TIFFTAG_PIXAR_MATRIX_WORLDTOCAMERA, 16,16, TIFF_FLOAT, FIELD_MATRIX_WORLDTOCAMERA, TRUE, FALSE, "MatrixWorldToCamera" }, /* end Pixar tags */ }; #define N(a) (sizeof (a) / sizeof (a[0])) void _TIFFSetupFieldInfo(TIFF* tif) { if (tif->tif_fieldinfo) { _TIFFfree(tif->tif_fieldinfo); tif->tif_nfields = 0; } _TIFFMergeFieldInfo(tif, tiffFieldInfo, N(tiffFieldInfo)); } static int tagCompare(const void* a, const void* b) { const TIFFFieldInfo* ta = *(const TIFFFieldInfo**) a; const TIFFFieldInfo* tb = *(const TIFFFieldInfo**) b; /* NB: be careful of return values for 16-bit platforms */ if (ta->field_tag != tb->field_tag) return (ta->field_tag < tb->field_tag ? -1 : 1); else return (tb->field_type < ta->field_type ? -1 : 1); } void _TIFFMergeFieldInfo(TIFF* tif, const TIFFFieldInfo info[], int n) { TIFFFieldInfo** tp; int i; if (tif->tif_nfields > 0) { tif->tif_fieldinfo = (TIFFFieldInfo**) _TIFFrealloc(tif->tif_fieldinfo, (tif->tif_nfields+n) * sizeof (TIFFFieldInfo*)); } else { tif->tif_fieldinfo = (TIFFFieldInfo**) _TIFFmalloc(n * sizeof (TIFFFieldInfo*)); } tp = &tif->tif_fieldinfo[tif->tif_nfields]; for (i = 0; i < n; i++) tp[i] = (TIFFFieldInfo*) &info[i]; /* XXX */ /* * NB: the core tags are presumed sorted correctly. */ if (tif->tif_nfields > 0) qsort(tif->tif_fieldinfo, (size_t) (tif->tif_nfields += n), sizeof (TIFFFieldInfo*), tagCompare); else tif->tif_nfields += n; } void _TIFFPrintFieldInfo(TIFF* tif, FILE* fd) { int i; fprintf(fd, "%s: \n", tif->tif_name); for (i = 0; i < tif->tif_nfields; i++) { const TIFFFieldInfo* fip = tif->tif_fieldinfo[i]; fprintf(fd, "field[%2d] %5lu, %2d, %2d, %d, %2d, %5s, %5s, %s\n" , i , (unsigned long) fip->field_tag , fip->field_readcount, fip->field_writecount , fip->field_type , fip->field_bit , fip->field_oktochange ? "TRUE" : "FALSE" , fip->field_passcount ? "TRUE" : "FALSE" , fip->field_name ); } } const int tiffDataWidth[] = { 1, /* nothing */ 1, /* TIFF_BYTE */ 1, /* TIFF_ASCII */ 2, /* TIFF_SHORT */ 4, /* TIFF_LONG */ 8, /* TIFF_RATIONAL */ 1, /* TIFF_SBYTE */ 1, /* TIFF_UNDEFINED */ 2, /* TIFF_SSHORT */ 4, /* TIFF_SLONG */ 8, /* TIFF_SRATIONAL */ 4, /* TIFF_FLOAT */ 8, /* TIFF_DOUBLE */ }; /* * Return nearest TIFFDataType to the sample type of an image. */ TIFFDataType _TIFFSampleToTagType(TIFF* tif) { int bps = (int) TIFFhowmany(tif->tif_dir.td_bitspersample, 8); switch (tif->tif_dir.td_sampleformat) { case SAMPLEFORMAT_IEEEFP: return (bps == 4 ? TIFF_FLOAT : TIFF_DOUBLE); case SAMPLEFORMAT_INT: return (bps <= 1 ? TIFF_SBYTE : bps <= 2 ? TIFF_SSHORT : TIFF_SLONG); case SAMPLEFORMAT_UINT: return (bps <= 1 ? TIFF_BYTE : bps <= 2 ? TIFF_SHORT : TIFF_LONG); case SAMPLEFORMAT_VOID: return (TIFF_UNDEFINED); } /*NOTREACHED*/ return (TIFF_UNDEFINED); } const TIFFFieldInfo* _TIFFFindFieldInfo(TIFF* tif, ttag_t tag, TIFFDataType dt) { static const TIFFFieldInfo *last = NULL; int i, n; if (last && last->field_tag == tag && (dt == TIFF_ANY || dt == last->field_type)) return (last); /* NB: if table gets big, use sorted search (e.g. binary search) */ for (i = 0, n = tif->tif_nfields; i < n; i++) { const TIFFFieldInfo* fip = tif->tif_fieldinfo[i]; if (fip->field_tag == tag && (dt == TIFF_ANY || fip->field_type == dt)) return (last = fip); } return ((const TIFFFieldInfo *)0); } #include #include const TIFFFieldInfo* _TIFFFieldWithTag(TIFF* tif, ttag_t tag) { const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY); if (!fip) { TIFFError("TIFFFieldWithTag", "Internal error, unknown tag 0x%x", (u_int) tag); assert(fip != NULL); /*NOTREACHED*/ } return (fip); } netpbm-8.2/libtiff/tif_dirread.c0100660000076400000000000011376407020044051015731 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_dirread.c,v 1.4 1999/11/27 21:07:53 warmerda Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library. * * Directory Read Support Routines. */ #include "tiffiop.h" #define IGNORE 0 /* tag placeholder used below */ #if HAVE_IEEEFP #define TIFFCvtIEEEFloatToNative(tif, n, fp) #define TIFFCvtIEEEDoubleToNative(tif, n, dp) #else extern void TIFFCvtIEEEFloatToNative(TIFF*, uint32, float*); extern void TIFFCvtIEEEDoubleToNative(TIFF*, uint32, double*); #endif static void EstimateStripByteCounts(TIFF*, TIFFDirEntry*, uint16); static void MissingRequired(TIFF*, const char*); static int CheckDirCount(TIFF*, TIFFDirEntry*, uint32); static tsize_t TIFFFetchData(TIFF*, TIFFDirEntry*, char*); static tsize_t TIFFFetchString(TIFF*, TIFFDirEntry*, char*); static float TIFFFetchRational(TIFF*, TIFFDirEntry*); static int TIFFFetchNormalTag(TIFF*, TIFFDirEntry*); static int TIFFFetchPerSampleShorts(TIFF*, TIFFDirEntry*, int*); static int TIFFFetchPerSampleAnys(TIFF*, TIFFDirEntry*, double*); static int TIFFFetchShortArray(TIFF*, TIFFDirEntry*, uint16*); static int TIFFFetchStripThing(TIFF*, TIFFDirEntry*, long, uint32**); static int TIFFFetchExtraSamples(TIFF*, TIFFDirEntry*); static int TIFFFetchRefBlackWhite(TIFF*, TIFFDirEntry*); static float TIFFFetchFloat(TIFF*, TIFFDirEntry*); static int TIFFFetchFloatArray(TIFF*, TIFFDirEntry*, float*); static int TIFFFetchDoubleArray(TIFF*, TIFFDirEntry*, double*); static int TIFFFetchAnyArray(TIFF*, TIFFDirEntry*, double*); static int TIFFFetchShortPair(TIFF*, TIFFDirEntry*); static void ChopUpSingleUncompressedStrip(TIFF*); static char * CheckMalloc(TIFF* tif, tsize_t n, const char* what) { char *cp = (char*)_TIFFmalloc(n); if (cp == NULL) TIFFError(tif->tif_name, "No space %s", what); return (cp); } /* * Read the next TIFF directory from a file * and convert it to the internal format. * We read directories sequentially. */ int TIFFReadDirectory(TIFF* tif) { register TIFFDirEntry* dp; register int n; register TIFFDirectory* td; TIFFDirEntry* dir; int iv; long v; double dv; const TIFFFieldInfo* fip; int fix; uint16 dircount; uint32 nextdiroff; char* cp; int diroutoforderwarning = 0; tif->tif_diroff = tif->tif_nextdiroff; if (tif->tif_diroff == 0) /* no more directories */ return (0); /* * Cleanup any previous compression state. */ (*tif->tif_cleanup)(tif); tif->tif_curdir++; nextdiroff = 0; if (!isMapped(tif)) { if (!SeekOK(tif, tif->tif_diroff)) { TIFFError(tif->tif_name, "Seek error accessing TIFF directory"); return (0); } if (!ReadOK(tif, &dircount, sizeof (uint16))) { TIFFError(tif->tif_name, "Can not read TIFF directory count"); return (0); } if (tif->tif_flags & TIFF_SWAB) TIFFSwabShort(&dircount); dir = (TIFFDirEntry *)CheckMalloc(tif, dircount * sizeof (TIFFDirEntry), "to read TIFF directory"); if (dir == NULL) return (0); if (!ReadOK(tif, dir, dircount*sizeof (TIFFDirEntry))) { TIFFError(tif->tif_name, "Can not read TIFF directory"); goto bad; } /* * Read offset to next directory for sequential scans. */ (void) ReadOK(tif, &nextdiroff, sizeof (uint32)); } else { toff_t off = tif->tif_diroff; if ((tsize_t) (off + sizeof (uint16)) > tif->tif_size) { TIFFError(tif->tif_name, "Can not read TIFF directory count"); return (0); } else _TIFFmemcpy(&dircount, tif->tif_base + off, sizeof (uint16)); off += sizeof (uint16); if (tif->tif_flags & TIFF_SWAB) TIFFSwabShort(&dircount); dir = (TIFFDirEntry *)CheckMalloc(tif, dircount * sizeof (TIFFDirEntry), "to read TIFF directory"); if (dir == NULL) return (0); if (((tsize_t) (off + dircount*sizeof (TIFFDirEntry))) > tif->tif_size) { TIFFError(tif->tif_name, "Can not read TIFF directory"); goto bad; } else _TIFFmemcpy(dir, tif->tif_base + off, dircount*sizeof (TIFFDirEntry)); off += dircount* sizeof (TIFFDirEntry); if (((tsize_t)(off + sizeof (uint32))) <= tif->tif_size) _TIFFmemcpy(&nextdiroff, tif->tif_base+off, sizeof (uint32)); } if (tif->tif_flags & TIFF_SWAB) TIFFSwabLong(&nextdiroff); tif->tif_nextdiroff = nextdiroff; tif->tif_flags &= ~TIFF_BEENWRITING; /* reset before new dir */ /* * Setup default value and then make a pass over * the fields to check type and tag information, * and to extract info required to size data * structures. A second pass is made afterwards * to read in everthing not taken in the first pass. */ td = &tif->tif_dir; /* free any old stuff and reinit */ TIFFFreeDirectory(tif); TIFFDefaultDirectory(tif); /* * Electronic Arts writes gray-scale TIFF files * without a PlanarConfiguration directory entry. * Thus we setup a default value here, even though * the TIFF spec says there is no default value. */ TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG); /* * Sigh, we must make a separate pass through the * directory for the following reason: * * We must process the Compression tag in the first pass * in order to merge in codec-private tag definitions (otherwise * we may get complaints about unknown tags). However, the * Compression tag may be dependent on the SamplesPerPixel * tag value because older TIFF specs permited Compression * to be written as a SamplesPerPixel-count tag entry. * Thus if we don't first figure out the correct SamplesPerPixel * tag value then we may end up ignoring the Compression tag * value because it has an incorrect count value (if the * true value of SamplesPerPixel is not 1). * * It sure would have been nice if Aldus had really thought * this stuff through carefully. */ for (dp = dir, n = dircount; n > 0; n--, dp++) { if (tif->tif_flags & TIFF_SWAB) { TIFFSwabArrayOfShort(&dp->tdir_tag, 2); TIFFSwabArrayOfLong(&dp->tdir_count, 2); } if (dp->tdir_tag == TIFFTAG_SAMPLESPERPIXEL) { if (!TIFFFetchNormalTag(tif, dp)) goto bad; dp->tdir_tag = IGNORE; } } /* * First real pass over the directory. */ fix = 0; for (dp = dir, n = dircount; n > 0; n--, dp++) { /* * Find the field information entry for this tag. * Added check for tags to ignore ... [BFC] */ if( TIFFReassignTagToIgnore(TIS_EXTRACT, dp->tdir_tag) ) dp->tdir_tag = IGNORE; if (dp->tdir_tag == IGNORE) continue; /* * Silicon Beach (at least) writes unordered * directory tags (violating the spec). Handle * it here, but be obnoxious (maybe they'll fix it?). */ if (dp->tdir_tag < tif->tif_fieldinfo[fix]->field_tag) { if (!diroutoforderwarning) { TIFFWarning(tif->tif_name, "invalid TIFF directory; tags are not sorted in ascending order"); diroutoforderwarning = 1; } fix = 0; /* O(n^2) */ } while (fix < tif->tif_nfields && tif->tif_fieldinfo[fix]->field_tag < dp->tdir_tag) fix++; if (fix == tif->tif_nfields || tif->tif_fieldinfo[fix]->field_tag != dp->tdir_tag) { TIFFWarning(tif->tif_name, "unknown field with tag %d (0x%x) ignored", dp->tdir_tag, dp->tdir_tag); dp->tdir_tag = IGNORE; fix = 0; /* restart search */ continue; } /* * Null out old tags that we ignore. */ if (tif->tif_fieldinfo[fix]->field_bit == FIELD_IGNORE) { ignore: dp->tdir_tag = IGNORE; continue; } /* * Check data type. */ fip = tif->tif_fieldinfo[fix]; while (dp->tdir_type != (u_short) fip->field_type) { if (fip->field_type == TIFF_ANY) /* wildcard */ break; fip++, fix++; if (fix == tif->tif_nfields || fip->field_tag != dp->tdir_tag) { TIFFWarning(tif->tif_name, "wrong data type %d for \"%s\"; tag ignored", dp->tdir_type, fip[-1].field_name); goto ignore; } } /* * Check count if known in advance. */ if (fip->field_readcount != TIFF_VARIABLE) { uint32 expected = (fip->field_readcount == TIFF_SPP) ? (uint32) td->td_samplesperpixel : (uint32) fip->field_readcount; if (!CheckDirCount(tif, dp, expected)) goto ignore; } switch (dp->tdir_tag) { case TIFFTAG_COMPRESSION: /* * The 5.0 spec says the Compression tag has * one value, while earlier specs say it has * one value per sample. Because of this, we * accept the tag if one value is supplied. */ if (dp->tdir_count == 1) { v = TIFFExtractData(tif, dp->tdir_type, dp->tdir_offset); if (!TIFFSetField(tif, dp->tdir_tag, (int)v)) goto bad; break; } if (!TIFFFetchPerSampleShorts(tif, dp, &iv) || !TIFFSetField(tif, dp->tdir_tag, iv)) goto bad; dp->tdir_tag = IGNORE; break; case TIFFTAG_STRIPOFFSETS: case TIFFTAG_STRIPBYTECOUNTS: case TIFFTAG_TILEOFFSETS: case TIFFTAG_TILEBYTECOUNTS: TIFFSetFieldBit(tif, fip->field_bit); break; case TIFFTAG_IMAGEWIDTH: case TIFFTAG_IMAGELENGTH: case TIFFTAG_IMAGEDEPTH: case TIFFTAG_TILELENGTH: case TIFFTAG_TILEWIDTH: case TIFFTAG_TILEDEPTH: case TIFFTAG_PLANARCONFIG: case TIFFTAG_ROWSPERSTRIP: if (!TIFFFetchNormalTag(tif, dp)) goto bad; dp->tdir_tag = IGNORE; break; case TIFFTAG_EXTRASAMPLES: (void) TIFFFetchExtraSamples(tif, dp); dp->tdir_tag = IGNORE; break; } } /* * Allocate directory structure and setup defaults. */ if (!TIFFFieldSet(tif, FIELD_IMAGEDIMENSIONS)) { MissingRequired(tif, "ImageLength"); goto bad; } if (!TIFFFieldSet(tif, FIELD_PLANARCONFIG)) { MissingRequired(tif, "PlanarConfiguration"); goto bad; } /* * Setup appropriate structures (by strip or by tile) */ if (!TIFFFieldSet(tif, FIELD_TILEDIMENSIONS)) { td->td_nstrips = TIFFNumberOfStrips(tif); td->td_tilewidth = td->td_imagewidth; td->td_tilelength = td->td_rowsperstrip; td->td_tiledepth = td->td_imagedepth; tif->tif_flags &= ~TIFF_ISTILED; } else { td->td_nstrips = TIFFNumberOfTiles(tif); tif->tif_flags |= TIFF_ISTILED; } td->td_stripsperimage = td->td_nstrips; if (td->td_planarconfig == PLANARCONFIG_SEPARATE) td->td_stripsperimage /= td->td_samplesperpixel; if (!TIFFFieldSet(tif, FIELD_STRIPOFFSETS)) { MissingRequired(tif, isTiled(tif) ? "TileOffsets" : "StripOffsets"); goto bad; } /* * Second pass: extract other information. */ for (dp = dir, n = dircount; n > 0; n--, dp++) { if (dp->tdir_tag == IGNORE) continue; switch (dp->tdir_tag) { case TIFFTAG_MINSAMPLEVALUE: case TIFFTAG_MAXSAMPLEVALUE: case TIFFTAG_BITSPERSAMPLE: /* * The 5.0 spec says the Compression tag has * one value, while earlier specs say it has * one value per sample. Because of this, we * accept the tag if one value is supplied. * * The MinSampleValue, MaxSampleValue and * BitsPerSample tags are supposed to be written * as one value/sample, but some vendors incorrectly * write one value only -- so we accept that * as well (yech). */ if (dp->tdir_count == 1) { v = TIFFExtractData(tif, dp->tdir_type, dp->tdir_offset); if (!TIFFSetField(tif, dp->tdir_tag, (int)v)) goto bad; break; } /* fall thru... */ case TIFFTAG_DATATYPE: case TIFFTAG_SAMPLEFORMAT: if (!TIFFFetchPerSampleShorts(tif, dp, &iv) || !TIFFSetField(tif, dp->tdir_tag, iv)) goto bad; break; case TIFFTAG_SMINSAMPLEVALUE: case TIFFTAG_SMAXSAMPLEVALUE: if (!TIFFFetchPerSampleAnys(tif, dp, &dv) || !TIFFSetField(tif, dp->tdir_tag, dv)) goto bad; break; case TIFFTAG_STRIPOFFSETS: case TIFFTAG_TILEOFFSETS: if (!TIFFFetchStripThing(tif, dp, td->td_nstrips, &td->td_stripoffset)) goto bad; break; case TIFFTAG_STRIPBYTECOUNTS: case TIFFTAG_TILEBYTECOUNTS: if (!TIFFFetchStripThing(tif, dp, td->td_nstrips, &td->td_stripbytecount)) goto bad; break; case TIFFTAG_COLORMAP: case TIFFTAG_TRANSFERFUNCTION: /* * TransferFunction can have either 1x or 3x data * values; Colormap can have only 3x items. */ v = 1L<td_bitspersample; if (dp->tdir_tag == TIFFTAG_COLORMAP || dp->tdir_count != (uint32) v) { if (!CheckDirCount(tif, dp, (uint32)(3*v))) break; } v *= sizeof (uint16); cp = CheckMalloc(tif, dp->tdir_count * sizeof (uint16), "to read \"TransferFunction\" tag"); if (cp != NULL) { if (TIFFFetchData(tif, dp, cp)) { /* * This deals with there being only * one array to apply to all samples. */ uint32 c = (uint32)1 << td->td_bitspersample; if (dp->tdir_count == c) v = 0; TIFFSetField(tif, dp->tdir_tag, cp, cp+v, cp+2*v); } _TIFFfree(cp); } break; case TIFFTAG_PAGENUMBER: case TIFFTAG_HALFTONEHINTS: case TIFFTAG_YCBCRSUBSAMPLING: case TIFFTAG_DOTRANGE: (void) TIFFFetchShortPair(tif, dp); break; #ifdef COLORIMETRY_SUPPORT case TIFFTAG_REFERENCEBLACKWHITE: (void) TIFFFetchRefBlackWhite(tif, dp); break; #endif /* BEGIN REV 4.0 COMPATIBILITY */ case TIFFTAG_OSUBFILETYPE: v = 0; switch (TIFFExtractData(tif, dp->tdir_type, dp->tdir_offset)) { case OFILETYPE_REDUCEDIMAGE: v = FILETYPE_REDUCEDIMAGE; break; case OFILETYPE_PAGE: v = FILETYPE_PAGE; break; } if (v) (void) TIFFSetField(tif, TIFFTAG_SUBFILETYPE, (int)v); break; /* END REV 4.0 COMPATIBILITY */ default: (void) TIFFFetchNormalTag(tif, dp); break; } } /* * Verify Palette image has a Colormap. */ if (td->td_photometric == PHOTOMETRIC_PALETTE && !TIFFFieldSet(tif, FIELD_COLORMAP)) { MissingRequired(tif, "Colormap"); goto bad; } /* * Attempt to deal with a missing StripByteCounts tag. */ if (!TIFFFieldSet(tif, FIELD_STRIPBYTECOUNTS)) { /* * Some manufacturers violate the spec by not giving * the size of the strips. In this case, assume there * is one uncompressed strip of data. */ if ((td->td_planarconfig == PLANARCONFIG_CONTIG && td->td_nstrips > 1) || (td->td_planarconfig == PLANARCONFIG_SEPARATE && td->td_nstrips != td->td_samplesperpixel)) { MissingRequired(tif, "StripByteCounts"); goto bad; } TIFFWarning(tif->tif_name, "TIFF directory is missing required \"%s\" field, calculating from imagelength", _TIFFFieldWithTag(tif,TIFFTAG_STRIPBYTECOUNTS)->field_name); EstimateStripByteCounts(tif, dir, dircount); #define BYTECOUNTLOOKSBAD \ (td->td_stripbytecount[0] == 0 || \ (td->td_compression == COMPRESSION_NONE && \ td->td_stripbytecount[0] > TIFFGetFileSize(tif) - td->td_stripoffset[0])) } else if (td->td_nstrips == 1 && BYTECOUNTLOOKSBAD) { /* * Plexus (and others) sometimes give a value * of zero for a tag when they don't know what * the correct value is! Try and handle the * simple case of estimating the size of a one * strip image. */ TIFFWarning(tif->tif_name, "Bogus \"%s\" field, ignoring and calculating from imagelength", _TIFFFieldWithTag(tif,TIFFTAG_STRIPBYTECOUNTS)->field_name); EstimateStripByteCounts(tif, dir, dircount); } if (dir) _TIFFfree((char *)dir); if (!TIFFFieldSet(tif, FIELD_MAXSAMPLEVALUE)) td->td_maxsamplevalue = (uint16)((1L<td_bitspersample)-1); /* * Setup default compression scheme. */ if (!TIFFFieldSet(tif, FIELD_COMPRESSION)) TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE); /* * Some manufacturers make life difficult by writing * large amounts of uncompressed data as a single strip. * This is contrary to the recommendations of the spec. * The following makes an attempt at breaking such images * into strips closer to the recommended 8k bytes. A * side effect, however, is that the RowsPerStrip tag * value may be changed. */ if (td->td_nstrips == 1 && td->td_compression == COMPRESSION_NONE && (tif->tif_flags & (TIFF_STRIPCHOP|TIFF_ISTILED)) == TIFF_STRIPCHOP) ChopUpSingleUncompressedStrip(tif); /* * Reinitialize i/o since we are starting on a new directory. */ tif->tif_row = (uint32) -1; tif->tif_curstrip = (tstrip_t) -1; tif->tif_col = (uint32) -1; tif->tif_curtile = (ttile_t) -1; tif->tif_tilesize = TIFFTileSize(tif); tif->tif_scanlinesize = TIFFScanlineSize(tif); return (1); bad: if (dir) _TIFFfree(dir); return (0); } static void EstimateStripByteCounts(TIFF* tif, TIFFDirEntry* dir, uint16 dircount) { register TIFFDirEntry *dp; register TIFFDirectory *td = &tif->tif_dir; uint16 i; if (td->td_stripbytecount) _TIFFfree(td->td_stripbytecount); td->td_stripbytecount = (uint32*) CheckMalloc(tif, td->td_nstrips * sizeof (uint32), "for \"StripByteCounts\" array"); if (td->td_compression != COMPRESSION_NONE) { uint32 space = (uint32)(sizeof (TIFFHeader) + sizeof (uint16) + (dircount * sizeof (TIFFDirEntry)) + sizeof (uint32)); toff_t filesize = TIFFGetFileSize(tif); uint16 n; /* calculate amount of space used by indirect values */ for (dp = dir, n = dircount; n > 0; n--, dp++) { uint32 cc = dp->tdir_count*tiffDataWidth[dp->tdir_type]; if (cc > sizeof (uint32)) space += cc; } space = filesize - space; if (td->td_planarconfig == PLANARCONFIG_SEPARATE) space /= td->td_samplesperpixel; for (i = 0; i < td->td_nstrips; i++) td->td_stripbytecount[i] = space; /* * This gross hack handles the case were the offset to * the last strip is past the place where we think the strip * should begin. Since a strip of data must be contiguous, * it's safe to assume that we've overestimated the amount * of data in the strip and trim this number back accordingly. */ i--; if (((toff_t)(td->td_stripoffset[i]+td->td_stripbytecount[i])) > filesize) td->td_stripbytecount[i] = filesize - td->td_stripoffset[i]; } else { uint32 rowbytes = TIFFScanlineSize(tif); uint32 rowsperstrip = td->td_imagelength/td->td_stripsperimage; for (i = 0; i < td->td_nstrips; i++) td->td_stripbytecount[i] = rowbytes*rowsperstrip; } TIFFSetFieldBit(tif, FIELD_STRIPBYTECOUNTS); if (!TIFFFieldSet(tif, FIELD_ROWSPERSTRIP)) td->td_rowsperstrip = td->td_imagelength; } static void MissingRequired(TIFF* tif, const char* tagname) { TIFFError(tif->tif_name, "TIFF directory is missing required \"%s\" field", tagname); } /* * Check the count field of a directory * entry against a known value. The caller * is expected to skip/ignore the tag if * there is a mismatch. */ static int CheckDirCount(TIFF* tif, TIFFDirEntry* dir, uint32 count) { if (count != dir->tdir_count) { TIFFWarning(tif->tif_name, "incorrect count for field \"%s\" (%lu, expecting %lu); tag ignored", _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name, dir->tdir_count, count); return (0); } return (1); } /* * Fetch a contiguous directory item. */ static tsize_t TIFFFetchData(TIFF* tif, TIFFDirEntry* dir, char* cp) { int w = tiffDataWidth[dir->tdir_type]; tsize_t cc = dir->tdir_count * w; if (!isMapped(tif)) { if (!SeekOK(tif, dir->tdir_offset)) goto bad; if (!ReadOK(tif, cp, cc)) goto bad; } else { if (((tsize_t) (dir->tdir_offset + cc)) > tif->tif_size) goto bad; _TIFFmemcpy(cp, tif->tif_base + dir->tdir_offset, cc); } if (tif->tif_flags & TIFF_SWAB) { switch (dir->tdir_type) { case TIFF_SHORT: case TIFF_SSHORT: TIFFSwabArrayOfShort((uint16*) cp, dir->tdir_count); break; case TIFF_LONG: case TIFF_SLONG: case TIFF_FLOAT: TIFFSwabArrayOfLong((uint32*) cp, dir->tdir_count); break; case TIFF_RATIONAL: case TIFF_SRATIONAL: TIFFSwabArrayOfLong((uint32*) cp, 2*dir->tdir_count); break; case TIFF_DOUBLE: TIFFSwabArrayOfDouble((double*) cp, dir->tdir_count); break; } } return (cc); bad: TIFFError(tif->tif_name, "Error fetching data for field \"%s\"", _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name); return ((tsize_t) 0); } /* * Fetch an ASCII item from the file. */ static tsize_t TIFFFetchString(TIFF* tif, TIFFDirEntry* dir, char* cp) { if (dir->tdir_count <= 4) { uint32 l = dir->tdir_offset; if (tif->tif_flags & TIFF_SWAB) TIFFSwabLong(&l); _TIFFmemcpy(cp, &l, dir->tdir_count); return (1); } return (TIFFFetchData(tif, dir, cp)); } /* * Convert numerator+denominator to float. */ static int cvtRational(TIFF* tif, TIFFDirEntry* dir, uint32 num, uint32 denom, float* rv) { if (denom == 0) { TIFFError(tif->tif_name, "%s: Rational with zero denominator (num = %lu)", _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name, num); return (0); } else { if (dir->tdir_type == TIFF_RATIONAL) *rv = ((float)num / (float)denom); else *rv = ((float)(int32)num / (float)(int32)denom); return (1); } } /* * Fetch a rational item from the file * at offset off and return the value * as a floating point number. */ static float TIFFFetchRational(TIFF* tif, TIFFDirEntry* dir) { uint32 l[2]; float v; return (!TIFFFetchData(tif, dir, (char *)l) || !cvtRational(tif, dir, l[0], l[1], &v) ? 1.0f : v); } /* * Fetch a single floating point value * from the offset field and return it * as a native float. */ static float TIFFFetchFloat(TIFF* tif, TIFFDirEntry* dir) { long l = TIFFExtractData(tif, dir->tdir_type, dir->tdir_offset); float v = *(float*) &l; TIFFCvtIEEEFloatToNative(tif, 1, &v); return (v); } /* * Fetch an array of BYTE or SBYTE values. */ static int TIFFFetchByteArray(TIFF* tif, TIFFDirEntry* dir, uint16* v) { if (dir->tdir_count <= 4) { /* * Extract data from offset field. */ if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) { switch (dir->tdir_count) { case 4: v[3] = (uint16)(dir->tdir_offset & 0xff); case 3: v[2] = (uint16)((dir->tdir_offset >> 8) & 0xff); case 2: v[1] = (uint16)((dir->tdir_offset >> 16) & 0xff); case 1: v[0] = (uint16)(dir->tdir_offset >> 24); } } else { switch (dir->tdir_count) { case 4: v[3] = (uint16)(dir->tdir_offset >> 24); case 3: v[2] = (uint16)((dir->tdir_offset >> 16) & 0xff); case 2: v[1] = (uint16)((dir->tdir_offset >> 8) & 0xff); case 1: v[0] = (uint16)(dir->tdir_offset & 0xff); } } return (1); } else return (TIFFFetchData(tif, dir, (char*) v) != 0); /* XXX */ } /* * Fetch an array of SHORT or SSHORT values. */ static int TIFFFetchShortArray(TIFF* tif, TIFFDirEntry* dir, uint16* v) { if (dir->tdir_count <= 2) { if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) { switch (dir->tdir_count) { case 2: v[1] = (uint16) (dir->tdir_offset & 0xffff); case 1: v[0] = (uint16) (dir->tdir_offset >> 16); } } else { switch (dir->tdir_count) { case 2: v[1] = (uint16) (dir->tdir_offset >> 16); case 1: v[0] = (uint16) (dir->tdir_offset & 0xffff); } } return (1); } else return (TIFFFetchData(tif, dir, (char *)v) != 0); } /* * Fetch a pair of SHORT or BYTE values. */ static int TIFFFetchShortPair(TIFF* tif, TIFFDirEntry* dir) { uint16 v[2]; int ok = 0; switch (dir->tdir_type) { case TIFF_SHORT: case TIFF_SSHORT: ok = TIFFFetchShortArray(tif, dir, v); break; case TIFF_BYTE: case TIFF_SBYTE: ok = TIFFFetchByteArray(tif, dir, v); break; } if (ok) TIFFSetField(tif, dir->tdir_tag, v[0], v[1]); return (ok); } /* * Fetch an array of LONG or SLONG values. */ static int TIFFFetchLongArray(TIFF* tif, TIFFDirEntry* dir, uint32* v) { if (dir->tdir_count == 1) { v[0] = dir->tdir_offset; return (1); } else return (TIFFFetchData(tif, dir, (char*) v) != 0); } /* * Fetch an array of RATIONAL or SRATIONAL values. */ static int TIFFFetchRationalArray(TIFF* tif, TIFFDirEntry* dir, float* v) { int ok = 0; uint32* l; l = (uint32*)CheckMalloc(tif, dir->tdir_count*tiffDataWidth[dir->tdir_type], "to fetch array of rationals"); if (l) { if (TIFFFetchData(tif, dir, (char *)l)) { uint32 i; for (i = 0; i < dir->tdir_count; i++) { ok = cvtRational(tif, dir, l[2*i+0], l[2*i+1], &v[i]); if (!ok) break; } } _TIFFfree((char *)l); } return (ok); } /* * Fetch an array of FLOAT values. */ static int TIFFFetchFloatArray(TIFF* tif, TIFFDirEntry* dir, float* v) { if (dir->tdir_count == 1) { v[0] = *(float*) &dir->tdir_offset; TIFFCvtIEEEFloatToNative(tif, dir->tdir_count, v); return (1); } else if (TIFFFetchData(tif, dir, (char*) v)) { TIFFCvtIEEEFloatToNative(tif, dir->tdir_count, v); return (1); } else return (0); } /* * Fetch an array of DOUBLE values. */ static int TIFFFetchDoubleArray(TIFF* tif, TIFFDirEntry* dir, double* v) { if (TIFFFetchData(tif, dir, (char*) v)) { TIFFCvtIEEEDoubleToNative(tif, dir->tdir_count, v); return (1); } else return (0); } /* * Fetch an array of ANY values. The actual values are * returned as doubles which should be able hold all the * types. Yes, there really should be an tany_t to avoid * this potential non-portability ... Note in particular * that we assume that the double return value vector is * large enough to read in any fundamental type. We use * that vector as a buffer to read in the base type vector * and then convert it in place to double (from end * to front of course). */ static int TIFFFetchAnyArray(TIFF* tif, TIFFDirEntry* dir, double* v) { int i; switch (dir->tdir_type) { case TIFF_BYTE: case TIFF_SBYTE: if (!TIFFFetchByteArray(tif, dir, (uint16*) v)) return (0); if (dir->tdir_type == TIFF_BYTE) { uint16* vp = (uint16*) v; for (i = dir->tdir_count-1; i >= 0; i--) v[i] = vp[i]; } else { int16* vp = (int16*) v; for (i = dir->tdir_count-1; i >= 0; i--) v[i] = vp[i]; } break; case TIFF_SHORT: case TIFF_SSHORT: if (!TIFFFetchShortArray(tif, dir, (uint16*) v)) return (0); if (dir->tdir_type == TIFF_SHORT) { uint16* vp = (uint16*) v; for (i = dir->tdir_count-1; i >= 0; i--) v[i] = vp[i]; } else { int16* vp = (int16*) v; for (i = dir->tdir_count-1; i >= 0; i--) v[i] = vp[i]; } break; case TIFF_LONG: case TIFF_SLONG: if (!TIFFFetchLongArray(tif, dir, (uint32*) v)) return (0); if (dir->tdir_type == TIFF_LONG) { uint32* vp = (uint32*) v; for (i = dir->tdir_count-1; i >= 0; i--) v[i] = vp[i]; } else { int32* vp = (int32*) v; for (i = dir->tdir_count-1; i >= 0; i--) v[i] = vp[i]; } break; case TIFF_RATIONAL: case TIFF_SRATIONAL: if (!TIFFFetchRationalArray(tif, dir, (float*) v)) return (0); { float* vp = (float*) v; for (i = dir->tdir_count-1; i >= 0; i--) v[i] = vp[i]; } break; case TIFF_FLOAT: if (!TIFFFetchFloatArray(tif, dir, (float*) v)) return (0); { float* vp = (float*) v; for (i = dir->tdir_count-1; i >= 0; i--) v[i] = vp[i]; } break; case TIFF_DOUBLE: return (TIFFFetchDoubleArray(tif, dir, (double*) v)); default: /* TIFF_NOTYPE */ /* TIFF_ASCII */ /* TIFF_UNDEFINED */ TIFFError(tif->tif_name, "Cannot read TIFF_ANY type %d for field \"%s\"", _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name); return (0); } return (1); } /* * Fetch a tag that is not handled by special case code. */ static int TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp) { static const char mesg[] = "to fetch tag value"; int ok = 0; const TIFFFieldInfo* fip = _TIFFFieldWithTag(tif, dp->tdir_tag); if (dp->tdir_count > 1) { /* array of values */ char* cp = NULL; switch (dp->tdir_type) { case TIFF_BYTE: case TIFF_SBYTE: /* NB: always expand BYTE values to shorts */ cp = CheckMalloc(tif, dp->tdir_count * sizeof (uint16), mesg); ok = cp && TIFFFetchByteArray(tif, dp, (uint16*) cp); break; case TIFF_SHORT: case TIFF_SSHORT: cp = CheckMalloc(tif, dp->tdir_count * sizeof (uint16), mesg); ok = cp && TIFFFetchShortArray(tif, dp, (uint16*) cp); break; case TIFF_LONG: case TIFF_SLONG: cp = CheckMalloc(tif, dp->tdir_count * sizeof (uint32), mesg); ok = cp && TIFFFetchLongArray(tif, dp, (uint32*) cp); break; case TIFF_RATIONAL: case TIFF_SRATIONAL: cp = CheckMalloc(tif, dp->tdir_count * sizeof (float), mesg); ok = cp && TIFFFetchRationalArray(tif, dp, (float*) cp); break; case TIFF_FLOAT: cp = CheckMalloc(tif, dp->tdir_count * sizeof (float), mesg); ok = cp && TIFFFetchFloatArray(tif, dp, (float*) cp); break; case TIFF_DOUBLE: cp = CheckMalloc(tif, dp->tdir_count * sizeof (double), mesg); ok = cp && TIFFFetchDoubleArray(tif, dp, (double*) cp); break; case TIFF_ASCII: case TIFF_UNDEFINED: /* bit of a cheat... */ /* * Some vendors write strings w/o the trailing * NULL byte, so always append one just in case. */ cp = CheckMalloc(tif, dp->tdir_count+1, mesg); if( (ok = (cp && TIFFFetchString(tif, dp, cp))) != 0 ) cp[dp->tdir_count] = '\0'; /* XXX */ break; } if (ok) { ok = (fip->field_passcount ? TIFFSetField(tif, dp->tdir_tag, dp->tdir_count, cp) : TIFFSetField(tif, dp->tdir_tag, cp)); } if (cp != NULL) _TIFFfree(cp); } else if (CheckDirCount(tif, dp, 1)) { /* singleton value */ switch (dp->tdir_type) { case TIFF_BYTE: case TIFF_SBYTE: case TIFF_SHORT: case TIFF_SSHORT: /* * If the tag is also acceptable as a LONG or SLONG * then TIFFSetField will expect an uint32 parameter * passed to it (through varargs). Thus, for machines * where sizeof (int) != sizeof (uint32) we must do * a careful check here. It's hard to say if this * is worth optimizing. * * NB: We use TIFFFieldWithTag here knowing that * it returns us the first entry in the table * for the tag and that that entry is for the * widest potential data type the tag may have. */ { TIFFDataType type = fip->field_type; if (type != TIFF_LONG && type != TIFF_SLONG) { uint16 v = (uint16) TIFFExtractData(tif, dp->tdir_type, dp->tdir_offset); ok = (fip->field_passcount ? TIFFSetField(tif, dp->tdir_tag, 1, &v) : TIFFSetField(tif, dp->tdir_tag, v)); break; } } /* fall thru... */ case TIFF_LONG: case TIFF_SLONG: { uint32 v32 = TIFFExtractData(tif, dp->tdir_type, dp->tdir_offset); ok = (fip->field_passcount ? TIFFSetField(tif, dp->tdir_tag, 1, &v32) : TIFFSetField(tif, dp->tdir_tag, v32)); } break; case TIFF_RATIONAL: case TIFF_SRATIONAL: case TIFF_FLOAT: { float v = (dp->tdir_type == TIFF_FLOAT ? TIFFFetchFloat(tif, dp) : TIFFFetchRational(tif, dp)); ok = (fip->field_passcount ? TIFFSetField(tif, dp->tdir_tag, 1, &v) : TIFFSetField(tif, dp->tdir_tag, v)); } break; case TIFF_DOUBLE: { double v; ok = (TIFFFetchDoubleArray(tif, dp, &v) && (fip->field_passcount ? TIFFSetField(tif, dp->tdir_tag, 1, &v) : TIFFSetField(tif, dp->tdir_tag, v)) ); } break; case TIFF_ASCII: case TIFF_UNDEFINED: /* bit of a cheat... */ { char c[2]; if( (ok = (TIFFFetchString(tif, dp, c) != 0)) != 0 ){ c[1] = '\0'; /* XXX paranoid */ ok = TIFFSetField(tif, dp->tdir_tag, c); } } break; } } return (ok); } #define NITEMS(x) (sizeof (x) / sizeof (x[0])) /* * Fetch samples/pixel short values for * the specified tag and verify that * all values are the same. */ static int TIFFFetchPerSampleShorts(TIFF* tif, TIFFDirEntry* dir, int* pl) { int samples = tif->tif_dir.td_samplesperpixel; int status = 0; if (CheckDirCount(tif, dir, (uint32) samples)) { uint16 buf[10]; uint16* v = buf; if (samples > NITEMS(buf)) v = (uint16*) _TIFFmalloc(samples * sizeof (uint16)); if (TIFFFetchShortArray(tif, dir, v)) { int i; for (i = 1; i < samples; i++) if (v[i] != v[0]) { TIFFError(tif->tif_name, "Cannot handle different per-sample values for field \"%s\"", _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name); goto bad; } *pl = v[0]; status = 1; } bad: if (v != buf) _TIFFfree((char*) v); } return (status); } /* * Fetch samples/pixel ANY values for * the specified tag and verify that * all values are the same. */ static int TIFFFetchPerSampleAnys(TIFF* tif, TIFFDirEntry* dir, double* pl) { int samples = (int) tif->tif_dir.td_samplesperpixel; int status = 0; if (CheckDirCount(tif, dir, (uint32) samples)) { double buf[10]; double* v = buf; if (samples > NITEMS(buf)) v = (double*) _TIFFmalloc(samples * sizeof (double)); if (TIFFFetchAnyArray(tif, dir, v)) { int i; for (i = 1; i < samples; i++) if (v[i] != v[0]) { TIFFError(tif->tif_name, "Cannot handle different per-sample values for field \"%s\"", _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name); goto bad; } *pl = v[0]; status = 1; } bad: if (v != buf) _TIFFfree(v); } return (status); } #undef NITEMS /* * Fetch a set of offsets or lengths. * While this routine says "strips", * in fact it's also used for tiles. */ static int TIFFFetchStripThing(TIFF* tif, TIFFDirEntry* dir, long nstrips, uint32** lpp) { register uint32* lp; int status; if (!CheckDirCount(tif, dir, (uint32) nstrips)) return (0); /* * Allocate space for strip information. */ if (*lpp == NULL && (*lpp = (uint32 *)CheckMalloc(tif, nstrips * sizeof (uint32), "for strip array")) == NULL) return (0); lp = *lpp; if (dir->tdir_type == (int)TIFF_SHORT) { /* * Handle uint16->uint32 expansion. */ uint16* dp = (uint16*) CheckMalloc(tif, dir->tdir_count* sizeof (uint16), "to fetch strip tag"); if (dp == NULL) return (0); if( (status = TIFFFetchShortArray(tif, dir, dp)) != 0 ) { register uint16* wp = dp; while (nstrips-- > 0) *lp++ = *wp++; } _TIFFfree((char*) dp); } else status = TIFFFetchLongArray(tif, dir, lp); return (status); } #define NITEMS(x) (sizeof (x) / sizeof (x[0])) /* * Fetch and set the ExtraSamples tag. */ static int TIFFFetchExtraSamples(TIFF* tif, TIFFDirEntry* dir) { uint16 buf[10]; uint16* v = buf; int status; if (dir->tdir_count > NITEMS(buf)) v = (uint16*) _TIFFmalloc(dir->tdir_count * sizeof (uint16)); if (dir->tdir_type == TIFF_BYTE) status = TIFFFetchByteArray(tif, dir, v); else status = TIFFFetchShortArray(tif, dir, v); if (status) status = TIFFSetField(tif, dir->tdir_tag, dir->tdir_count, v); if (v != buf) _TIFFfree((char*) v); return (status); } #undef NITEMS #ifdef COLORIMETRY_SUPPORT /* * Fetch and set the RefBlackWhite tag. */ static int TIFFFetchRefBlackWhite(TIFF* tif, TIFFDirEntry* dir) { static const char mesg[] = "for \"ReferenceBlackWhite\" array"; char* cp; int ok; if (dir->tdir_type == TIFF_RATIONAL) return (TIFFFetchNormalTag(tif, dir)); /* * Handle LONG's for backward compatibility. */ cp = CheckMalloc(tif, dir->tdir_count * sizeof (uint32), mesg); if( (ok = (cp && TIFFFetchLongArray(tif, dir, (uint32*) cp))) != 0) { float* fp = (float*) CheckMalloc(tif, dir->tdir_count * sizeof (float), mesg); if( (ok = (fp != NULL)) != 0 ) { uint32 i; for (i = 0; i < dir->tdir_count; i++) fp[i] = (float)((uint32*) cp)[i]; ok = TIFFSetField(tif, dir->tdir_tag, fp); _TIFFfree((char*) fp); } } if (cp) _TIFFfree(cp); return (ok); } #endif /* * Replace a single strip (tile) of uncompressed data by * multiple strips (tiles), each approximately 8Kbytes. * This is useful for dealing with large images or * for dealing with machines with a limited amount * memory. */ static void ChopUpSingleUncompressedStrip(TIFF* tif) { register TIFFDirectory *td = &tif->tif_dir; uint32 bytecount = td->td_stripbytecount[0]; uint32 offset = td->td_stripoffset[0]; tsize_t rowbytes = TIFFVTileSize(tif, 1), stripbytes; tstrip_t strip, nstrips, rowsperstrip; uint32* newcounts; uint32* newoffsets; /* * Make the rows hold at least one * scanline, but fill 8k if possible. */ if (rowbytes > 8192) { stripbytes = rowbytes; rowsperstrip = 1; } else { rowsperstrip = 8192 / rowbytes; stripbytes = rowbytes * rowsperstrip; } /* never increase the number of strips in an image */ if (rowsperstrip >= td->td_rowsperstrip) return; nstrips = (tstrip_t) TIFFhowmany(bytecount, stripbytes); newcounts = (uint32*) CheckMalloc(tif, nstrips * sizeof (uint32), "for chopped \"StripByteCounts\" array"); newoffsets = (uint32*) CheckMalloc(tif, nstrips * sizeof (uint32), "for chopped \"StripOffsets\" array"); if (newcounts == NULL || newoffsets == NULL) { /* * Unable to allocate new strip information, give * up and use the original one strip information. */ if (newcounts != NULL) _TIFFfree(newcounts); if (newoffsets != NULL) _TIFFfree(newoffsets); return; } /* * Fill the strip information arrays with * new bytecounts and offsets that reflect * the broken-up format. */ for (strip = 0; strip < nstrips; strip++) { if (stripbytes > (tsize_t) bytecount) stripbytes = bytecount; newcounts[strip] = stripbytes; newoffsets[strip] = offset; offset += stripbytes; bytecount -= stripbytes; } /* * Replace old single strip info with multi-strip info. */ td->td_stripsperimage = td->td_nstrips = nstrips; TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, rowsperstrip); _TIFFfree(td->td_stripbytecount); _TIFFfree(td->td_stripoffset); td->td_stripbytecount = newcounts; td->td_stripoffset = newoffsets; } netpbm-8.2/libtiff/tif_dirwrite.c0100660000076400000000000006742207020044521016151 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_dirwrite.c,v 1.4 1999/11/27 21:12:49 warmerda Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library. * * Directory Write Support Routines. */ #include "tiffiop.h" #if HAVE_IEEEFP #define TIFFCvtNativeToIEEEFloat(tif, n, fp) #define TIFFCvtNativeToIEEEDouble(tif, n, dp) #else extern void TIFFCvtNativeToIEEEFloat(TIFF*, uint32, float*); extern void TIFFCvtNativeToIEEEDouble(TIFF*, uint32, double*); #endif static int TIFFWriteNormalTag(TIFF*, TIFFDirEntry*, const TIFFFieldInfo*); static void TIFFSetupShortLong(TIFF*, ttag_t, TIFFDirEntry*, uint32); static int TIFFSetupShortPair(TIFF*, ttag_t, TIFFDirEntry*); static int TIFFWritePerSampleShorts(TIFF*, ttag_t, TIFFDirEntry*); static int TIFFWritePerSampleAnys(TIFF*, TIFFDataType, ttag_t, TIFFDirEntry*); static int TIFFWriteShortTable(TIFF*, ttag_t, TIFFDirEntry*, uint32, uint16**); static int TIFFWriteShortArray(TIFF*, TIFFDataType, ttag_t, TIFFDirEntry*, uint32, uint16*); static int TIFFWriteLongArray(TIFF *, TIFFDataType, ttag_t, TIFFDirEntry*, uint32, uint32*); static int TIFFWriteRationalArray(TIFF *, TIFFDataType, ttag_t, TIFFDirEntry*, uint32, float*); static int TIFFWriteFloatArray(TIFF *, TIFFDataType, ttag_t, TIFFDirEntry*, uint32, float*); static int TIFFWriteDoubleArray(TIFF *, TIFFDataType, ttag_t, TIFFDirEntry*, uint32, double*); static int TIFFWriteByteArray(TIFF*, TIFFDirEntry*, char*); static int TIFFWriteAnyArray(TIFF*, TIFFDataType, ttag_t, TIFFDirEntry*, uint32, double*); #ifdef COLORIMETRY_SUPPORT static int TIFFWriteTransferFunction(TIFF*, TIFFDirEntry*); #endif #ifdef CMYK_SUPPORT static int TIFFWriteInkNames(TIFF*, TIFFDirEntry*); #endif static int TIFFWriteData(TIFF*, TIFFDirEntry*, char*); static int TIFFLinkDirectory(TIFF*); #define WriteRationalPair(type, tag1, v1, tag2, v2) { \ if (!TIFFWriteRational(tif, type, tag1, dir, v1)) \ goto bad; \ if (!TIFFWriteRational(tif, type, tag2, dir+1, v2)) \ goto bad; \ dir++; \ } #define TIFFWriteRational(tif, type, tag, dir, v) \ TIFFWriteRationalArray((tif), (type), (tag), (dir), 1, &(v)) #ifndef TIFFWriteRational static int TIFFWriteRational(TIFF*, TIFFDataType, ttag_t, TIFFDirEntry*, float); #endif /* * Write the contents of the current directory * to the specified file. This routine doesn't * handle overwriting a directory with auxiliary * storage that's been changed. */ int TIFFWriteDirectory(TIFF* tif) { uint16 dircount; uint32 diroff; ttag_t tag; uint32 nfields; tsize_t dirsize; char* data; TIFFDirEntry* dir; TIFFDirectory* td; u_long b, fields[FIELD_SETLONGS]; int fi, nfi; if (tif->tif_mode == O_RDONLY) return (1); /* * Clear write state so that subsequent images with * different characteristics get the right buffers * setup for them. */ if (tif->tif_flags & TIFF_POSTENCODE) { tif->tif_flags &= ~TIFF_POSTENCODE; if (!(*tif->tif_postencode)(tif)) { TIFFError(tif->tif_name, "Error post-encoding before directory write"); return (0); } } (*tif->tif_close)(tif); /* shutdown encoder */ /* * Flush any data that might have been written * by the compression close+cleanup routines. */ if (tif->tif_rawcc > 0 && !TIFFFlushData1(tif)) { TIFFError(tif->tif_name, "Error flushing data before directory write"); return (0); } if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) { _TIFFfree(tif->tif_rawdata); tif->tif_rawdata = NULL; tif->tif_rawcc = 0; } tif->tif_flags &= ~(TIFF_BEENWRITING|TIFF_BUFFERSETUP); td = &tif->tif_dir; /* * Size the directory so that we can calculate * offsets for the data items that aren't kept * in-place in each field. */ nfields = 0; for (b = 0; b <= FIELD_LAST; b++) if (TIFFFieldSet(tif, b)) nfields += (b < FIELD_SUBFILETYPE ? 2 : 1); dirsize = nfields * sizeof (TIFFDirEntry); data = (char*) _TIFFmalloc(dirsize); if (data == NULL) { TIFFError(tif->tif_name, "Cannot write directory, out of space"); return (0); } /* * Directory hasn't been placed yet, put * it at the end of the file and link it * into the existing directory structure. */ if (tif->tif_diroff == 0 && !TIFFLinkDirectory(tif)) goto bad; tif->tif_dataoff = (toff_t)( tif->tif_diroff + sizeof (uint16) + dirsize + sizeof (toff_t)); if (tif->tif_dataoff & 1) tif->tif_dataoff++; (void) TIFFSeekFile(tif, tif->tif_dataoff, SEEK_SET); tif->tif_curdir++; dir = (TIFFDirEntry*) data; /* * Setup external form of directory * entries and write data items. */ _TIFFmemcpy(fields, td->td_fieldsset, sizeof (fields)); /* * Write out ExtraSamples tag only if * extra samples are present in the data. */ if (FieldSet(fields, FIELD_EXTRASAMPLES) && !td->td_extrasamples) { ResetFieldBit(fields, FIELD_EXTRASAMPLES); nfields--; dirsize -= sizeof (TIFFDirEntry); } /*XXX*/ for (fi = 0, nfi = tif->tif_nfields; nfi > 0; nfi--, fi++) { const TIFFFieldInfo* fip = tif->tif_fieldinfo[fi]; if (!FieldSet(fields, fip->field_bit)) continue; switch (fip->field_bit) { case FIELD_STRIPOFFSETS: /* * We use one field bit for both strip and tile * offsets, and so must be careful in selecting * the appropriate field descriptor (so that tags * are written in sorted order). */ tag = isTiled(tif) ? TIFFTAG_TILEOFFSETS : TIFFTAG_STRIPOFFSETS; if (tag != fip->field_tag) continue; if (!TIFFWriteLongArray(tif, TIFF_LONG, tag, dir, (uint32) td->td_nstrips, td->td_stripoffset)) goto bad; break; case FIELD_STRIPBYTECOUNTS: /* * We use one field bit for both strip and tile * byte counts, and so must be careful in selecting * the appropriate field descriptor (so that tags * are written in sorted order). */ tag = isTiled(tif) ? TIFFTAG_TILEBYTECOUNTS : TIFFTAG_STRIPBYTECOUNTS; if (tag != fip->field_tag) continue; if (!TIFFWriteLongArray(tif, TIFF_LONG, tag, dir, (uint32) td->td_nstrips, td->td_stripbytecount)) goto bad; break; case FIELD_ROWSPERSTRIP: TIFFSetupShortLong(tif, TIFFTAG_ROWSPERSTRIP, dir, td->td_rowsperstrip); break; case FIELD_COLORMAP: if (!TIFFWriteShortTable(tif, TIFFTAG_COLORMAP, dir, 3, td->td_colormap)) goto bad; break; case FIELD_IMAGEDIMENSIONS: TIFFSetupShortLong(tif, TIFFTAG_IMAGEWIDTH, dir++, td->td_imagewidth); TIFFSetupShortLong(tif, TIFFTAG_IMAGELENGTH, dir, td->td_imagelength); break; case FIELD_TILEDIMENSIONS: TIFFSetupShortLong(tif, TIFFTAG_TILEWIDTH, dir++, td->td_tilewidth); TIFFSetupShortLong(tif, TIFFTAG_TILELENGTH, dir, td->td_tilelength); break; case FIELD_POSITION: WriteRationalPair(TIFF_RATIONAL, TIFFTAG_XPOSITION, td->td_xposition, TIFFTAG_YPOSITION, td->td_yposition); break; case FIELD_RESOLUTION: WriteRationalPair(TIFF_RATIONAL, TIFFTAG_XRESOLUTION, td->td_xresolution, TIFFTAG_YRESOLUTION, td->td_yresolution); break; case FIELD_BITSPERSAMPLE: case FIELD_MINSAMPLEVALUE: case FIELD_MAXSAMPLEVALUE: case FIELD_SAMPLEFORMAT: if (!TIFFWritePerSampleShorts(tif, fip->field_tag, dir)) goto bad; break; case FIELD_SMINSAMPLEVALUE: case FIELD_SMAXSAMPLEVALUE: if (!TIFFWritePerSampleAnys(tif, _TIFFSampleToTagType(tif), fip->field_tag, dir)) goto bad; break; case FIELD_PAGENUMBER: case FIELD_HALFTONEHINTS: #ifdef YCBCR_SUPPORT case FIELD_YCBCRSUBSAMPLING: #endif #ifdef CMYK_SUPPORT case FIELD_DOTRANGE: #endif if (!TIFFSetupShortPair(tif, fip->field_tag, dir)) goto bad; break; #ifdef CMYK_SUPPORT case FIELD_INKNAMES: if (!TIFFWriteInkNames(tif, dir)) goto bad; break; #endif #ifdef COLORIMETRY_SUPPORT case FIELD_TRANSFERFUNCTION: if (!TIFFWriteTransferFunction(tif, dir)) goto bad; break; #endif #if SUBIFD_SUPPORT case FIELD_SUBIFD: if (!TIFFWriteNormalTag(tif, dir, fip)) goto bad; /* * Total hack: if this directory includes a SubIFD * tag then force the next directories to be * written as ``sub directories'' of this one. This * is used to write things like thumbnails and * image masks that one wants to keep out of the * normal directory linkage access mechanism. */ if (dir->tdir_count > 0) { tif->tif_flags |= TIFF_INSUBIFD; tif->tif_nsubifd = (uint16) dir->tdir_count; if (dir->tdir_count > 1) tif->tif_subifdoff = dir->tdir_offset; else tif->tif_subifdoff = (uint32)( tif->tif_diroff + sizeof (uint16) + ((char*)&dir->tdir_offset-data)); } break; #endif default: if (!TIFFWriteNormalTag(tif, dir, fip)) goto bad; break; } dir++; ResetFieldBit(fields, fip->field_bit); } /* * Write directory. */ dircount = (uint16) nfields; diroff = (uint32) tif->tif_nextdiroff; if (tif->tif_flags & TIFF_SWAB) { /* * The file's byte order is opposite to the * native machine architecture. We overwrite * the directory information with impunity * because it'll be released below after we * write it to the file. Note that all the * other tag construction routines assume that * we do this byte-swapping; i.e. they only * byte-swap indirect data. */ for (dir = (TIFFDirEntry*) data; dircount; dir++, dircount--) { TIFFSwabArrayOfShort(&dir->tdir_tag, 2); TIFFSwabArrayOfLong(&dir->tdir_count, 2); } dircount = (uint16) nfields; TIFFSwabShort(&dircount); TIFFSwabLong(&diroff); } (void) TIFFSeekFile(tif, tif->tif_diroff, SEEK_SET); if (!WriteOK(tif, &dircount, sizeof (dircount))) { TIFFError(tif->tif_name, "Error writing directory count"); goto bad; } if (!WriteOK(tif, data, dirsize)) { TIFFError(tif->tif_name, "Error writing directory contents"); goto bad; } if (!WriteOK(tif, &diroff, sizeof (diroff))) { TIFFError(tif->tif_name, "Error writing directory link"); goto bad; } TIFFFreeDirectory(tif); _TIFFfree(data); tif->tif_flags &= ~TIFF_DIRTYDIRECT; (*tif->tif_cleanup)(tif); /* * Reset directory-related state for subsequent * directories. */ TIFFDefaultDirectory(tif); tif->tif_diroff = 0; tif->tif_curoff = 0; tif->tif_row = (uint32) -1; tif->tif_curstrip = (tstrip_t) -1; return (1); bad: _TIFFfree(data); return (0); } #undef WriteRationalPair /* * Process tags that are not special cased. */ static int TIFFWriteNormalTag(TIFF* tif, TIFFDirEntry* dir, const TIFFFieldInfo* fip) { u_short wc = (u_short) fip->field_writecount; uint32 wc2; dir->tdir_tag = (uint16) fip->field_tag; dir->tdir_type = (u_short) fip->field_type; dir->tdir_count = wc; #define WRITEF(x,y) x(tif, fip->field_type, fip->field_tag, dir, wc, y) switch (fip->field_type) { case TIFF_SHORT: case TIFF_SSHORT: if (wc > 1) { uint16* wp; if (wc == (u_short) TIFF_VARIABLE) TIFFGetField(tif, fip->field_tag, &wc, &wp); else TIFFGetField(tif, fip->field_tag, &wp); if (!WRITEF(TIFFWriteShortArray, wp)) return (0); } else { uint16 sv; TIFFGetField(tif, fip->field_tag, &sv); dir->tdir_offset = TIFFInsertData(tif, dir->tdir_type, sv); } break; case TIFF_LONG: case TIFF_SLONG: if (wc > 1) { uint32* lp; if (wc == (u_short) TIFF_VARIABLE) TIFFGetField(tif, fip->field_tag, &wc, &lp); else TIFFGetField(tif, fip->field_tag, &lp); if (!WRITEF(TIFFWriteLongArray, lp)) return (0); } else { /* XXX handle LONG->SHORT conversion */ TIFFGetField(tif, fip->field_tag, &dir->tdir_offset); } break; case TIFF_RATIONAL: case TIFF_SRATIONAL: if (wc > 1) { float* fp; if (wc == (u_short) TIFF_VARIABLE) TIFFGetField(tif, fip->field_tag, &wc, &fp); else TIFFGetField(tif, fip->field_tag, &fp); if (!WRITEF(TIFFWriteRationalArray, fp)) return (0); } else { float fv; TIFFGetField(tif, fip->field_tag, &fv); if (!WRITEF(TIFFWriteRationalArray, &fv)) return (0); } break; case TIFF_FLOAT: if (wc > 1) { float* fp; if (wc == (u_short) TIFF_VARIABLE) TIFFGetField(tif, fip->field_tag, &wc, &fp); else TIFFGetField(tif, fip->field_tag, &fp); if (!WRITEF(TIFFWriteFloatArray, fp)) return (0); } else { float fv; TIFFGetField(tif, fip->field_tag, &fv); if (!WRITEF(TIFFWriteFloatArray, &fv)) return (0); } break; case TIFF_DOUBLE: if (wc > 1) { double* dp; if (wc == (u_short) TIFF_VARIABLE) TIFFGetField(tif, fip->field_tag, &wc, &dp); else TIFFGetField(tif, fip->field_tag, &dp); if (!WRITEF(TIFFWriteDoubleArray, dp)) return (0); } else { double dv; TIFFGetField(tif, fip->field_tag, &dv); if (!WRITEF(TIFFWriteDoubleArray, &dv)) return (0); } break; case TIFF_ASCII: { char* cp; TIFFGetField(tif, fip->field_tag, &cp); dir->tdir_count = (uint32) (strlen(cp) + 1); if (!TIFFWriteByteArray(tif, dir, cp)) return (0); } break; /* added based on patch request from MARTIN.MCBRIDE.MM@agfa.co.uk, correctness not verified (FW, 99/08) */ case TIFF_BYTE: case TIFF_SBYTE: if (wc > 1) { char* cp; if (wc == (u_short) TIFF_VARIABLE) { TIFFGetField(tif, fip->field_tag, &wc, &cp); dir->tdir_count = wc; } else TIFFGetField(tif, fip->field_tag, &cp); if (!TIFFWriteByteArray(tif, dir, cp)) return (0); } else { char cv; TIFFGetField(tif, fip->field_tag, &cv); if (!TIFFWriteByteArray(tif, dir, &cv)) return (0); } break; case TIFF_UNDEFINED: { char* cp; if (wc == (u_short) TIFF_VARIABLE) { TIFFGetField(tif, fip->field_tag, &wc, &cp); dir->tdir_count = wc; } else if (wc == (u_short) TIFF_VARIABLE2) { TIFFGetField(tif, fip->field_tag, &wc2, &cp); dir->tdir_count = wc2; } else TIFFGetField(tif, fip->field_tag, &cp); if (!TIFFWriteByteArray(tif, dir, cp)) return (0); } break; case TIFF_NOTYPE: break; } return (1); } #undef WRITEF /* * Setup a directory entry with either a SHORT * or LONG type according to the value. */ static void TIFFSetupShortLong(TIFF* tif, ttag_t tag, TIFFDirEntry* dir, uint32 v) { dir->tdir_tag = (uint16) tag; dir->tdir_count = 1; if (v > 0xffffL) { dir->tdir_type = (short) TIFF_LONG; dir->tdir_offset = v; } else { dir->tdir_type = (short) TIFF_SHORT; dir->tdir_offset = TIFFInsertData(tif, (int) TIFF_SHORT, v); } } #undef MakeShortDirent #ifndef TIFFWriteRational /* * Setup a RATIONAL directory entry and * write the associated indirect value. */ static int TIFFWriteRational(TIFF* tif, TIFFDataType type, ttag_t tag, TIFFDirEntry* dir, float v) { return (TIFFWriteRationalArray(tif, type, tag, dir, 1, &v)); } #endif #define NITEMS(x) (sizeof (x) / sizeof (x[0])) /* * Setup a directory entry that references a * samples/pixel array of SHORT values and * (potentially) write the associated indirect * values. */ static int TIFFWritePerSampleShorts(TIFF* tif, ttag_t tag, TIFFDirEntry* dir) { uint16 buf[10], v; uint16* w = buf; int i, status, samples = tif->tif_dir.td_samplesperpixel; if (samples > NITEMS(buf)) w = (uint16*) _TIFFmalloc(samples * sizeof (uint16)); TIFFGetField(tif, tag, &v); for (i = 0; i < samples; i++) w[i] = v; status = TIFFWriteShortArray(tif, TIFF_SHORT, tag, dir, samples, w); if (w != buf) _TIFFfree((char*) w); return (status); } /* * Setup a directory entry that references a samples/pixel array of ``type'' * values and (potentially) write the associated indirect values. The source * data from TIFFGetField() for the specified tag must be returned as double. */ static int TIFFWritePerSampleAnys(TIFF* tif, TIFFDataType type, ttag_t tag, TIFFDirEntry* dir) { double buf[10], v; double* w = buf; int i, status; int samples = (int) tif->tif_dir.td_samplesperpixel; if (samples > NITEMS(buf)) w = (double*) _TIFFmalloc(samples * sizeof (double)); TIFFGetField(tif, tag, &v); for (i = 0; i < samples; i++) w[i] = v; status = TIFFWriteAnyArray(tif, type, tag, dir, samples, w); if (w != buf) _TIFFfree(w); return (status); } #undef NITEMS /* * Setup a pair of shorts that are returned by * value, rather than as a reference to an array. */ static int TIFFSetupShortPair(TIFF* tif, ttag_t tag, TIFFDirEntry* dir) { uint16 v[2]; TIFFGetField(tif, tag, &v[0], &v[1]); return (TIFFWriteShortArray(tif, TIFF_SHORT, tag, dir, 2, v)); } /* * Setup a directory entry for an NxM table of shorts, * where M is known to be 2**bitspersample, and write * the associated indirect data. */ static int TIFFWriteShortTable(TIFF* tif, ttag_t tag, TIFFDirEntry* dir, uint32 n, uint16** table) { uint32 i, off; dir->tdir_tag = (uint16) tag; dir->tdir_type = (short) TIFF_SHORT; /* XXX -- yech, fool TIFFWriteData */ dir->tdir_count = (uint32) (1L<tif_dir.td_bitspersample); off = tif->tif_dataoff; for (i = 0; i < n; i++) if (!TIFFWriteData(tif, dir, (char *)table[i])) return (0); dir->tdir_count *= n; dir->tdir_offset = off; return (1); } /* * Write/copy data associated with an ASCII or opaque tag value. */ static int TIFFWriteByteArray(TIFF* tif, TIFFDirEntry* dir, char* cp) { if (dir->tdir_count > 4) { if (!TIFFWriteData(tif, dir, cp)) return (0); } else _TIFFmemcpy(&dir->tdir_offset, cp, dir->tdir_count); return (1); } /* * Setup a directory entry of an array of SHORT * or SSHORT and write the associated indirect values. */ static int TIFFWriteShortArray(TIFF* tif, TIFFDataType type, ttag_t tag, TIFFDirEntry* dir, uint32 n, uint16* v) { dir->tdir_tag = (uint16) tag; dir->tdir_type = (short) type; dir->tdir_count = n; if (n <= 2) { if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) { dir->tdir_offset = (uint32) ((long) v[0] << 16); if (n == 2) dir->tdir_offset |= v[1] & 0xffff; } else { dir->tdir_offset = v[0] & 0xffff; if (n == 2) dir->tdir_offset |= (long) v[1] << 16; } return (1); } else return (TIFFWriteData(tif, dir, (char*) v)); } /* * Setup a directory entry of an array of LONG * or SLONG and write the associated indirect values. */ static int TIFFWriteLongArray(TIFF* tif, TIFFDataType type, ttag_t tag, TIFFDirEntry* dir, uint32 n, uint32* v) { dir->tdir_tag = (uint16) tag; dir->tdir_type = (short) type; dir->tdir_count = n; if (n == 1) { dir->tdir_offset = v[0]; return (1); } else return (TIFFWriteData(tif, dir, (char*) v)); } /* * Setup a directory entry of an array of RATIONAL * or SRATIONAL and write the associated indirect values. */ static int TIFFWriteRationalArray(TIFF* tif, TIFFDataType type, ttag_t tag, TIFFDirEntry* dir, uint32 n, float* v) { uint32 i; uint32* t; int status; dir->tdir_tag = (uint16) tag; dir->tdir_type = (short) type; dir->tdir_count = n; t = (uint32*) _TIFFmalloc(2*n * sizeof (uint32)); for (i = 0; i < n; i++) { float fv = v[i]; int sign = 1; uint32 den; if (fv < 0) { if (type == TIFF_RATIONAL) { TIFFWarning(tif->tif_name, "\"%s\": Information lost writing value (%g) as (unsigned) RATIONAL", _TIFFFieldWithTag(tif,tag)->field_name, fv); fv = 0; } else fv = -fv, sign = -1; } den = 1L; if (fv > 0) { while (fv < 1L<<(31-3) && den < 1L<<(31-3)) fv *= 1<<3, den *= 1L<<3; } t[2*i+0] = (uint32) (sign * (fv + 0.5)); t[2*i+1] = den; } status = TIFFWriteData(tif, dir, (char *)t); _TIFFfree((char*) t); return (status); } static int TIFFWriteFloatArray(TIFF* tif, TIFFDataType type, ttag_t tag, TIFFDirEntry* dir, uint32 n, float* v) { dir->tdir_tag = (uint16) tag; dir->tdir_type = (short) type; dir->tdir_count = n; TIFFCvtNativeToIEEEFloat(tif, n, v); if (n == 1) { dir->tdir_offset = *(uint32*) &v[0]; return (1); } else return (TIFFWriteData(tif, dir, (char*) v)); } static int TIFFWriteDoubleArray(TIFF* tif, TIFFDataType type, ttag_t tag, TIFFDirEntry* dir, uint32 n, double* v) { dir->tdir_tag = (uint16) tag; dir->tdir_type = (short) type; dir->tdir_count = n; TIFFCvtNativeToIEEEDouble(tif, n, v); return (TIFFWriteData(tif, dir, (char*) v)); } /* * Write an array of ``type'' values for a specified tag (i.e. this is a tag * which is allowed to have different types, e.g. SMaxSampleType). * Internally the data values are represented as double since a double can * hold any of the TIFF tag types (yes, this should really be an abstract * type tany_t for portability). The data is converted into the specified * type in a temporary buffer and then handed off to the appropriate array * writer. */ static int TIFFWriteAnyArray(TIFF* tif, TIFFDataType type, ttag_t tag, TIFFDirEntry* dir, uint32 n, double* v) { char buf[10 * sizeof(double)]; char* w = buf; int i, status = 0; if (n * tiffDataWidth[type] > sizeof buf) w = (char*) _TIFFmalloc(n * tiffDataWidth[type]); switch (type) { case TIFF_BYTE: { uint8* bp = (uint8*) w; for (i = 0; i < (int) n; i++) bp[i] = (uint8) v[i]; dir->tdir_tag = (uint16) tag; dir->tdir_type = (short) type; dir->tdir_count = n; if (!TIFFWriteByteArray(tif, dir, (char*) bp)) goto out; } break; case TIFF_SBYTE: { int8* bp = (int8*) w; for (i = 0; i < (int) n; i++) bp[i] = (int8) v[i]; dir->tdir_tag = (uint16) tag; dir->tdir_type = (short) type; dir->tdir_count = n; if (!TIFFWriteByteArray(tif, dir, (char*) bp)) goto out; } break; case TIFF_SHORT: { uint16* bp = (uint16*) w; for (i = 0; i < (int) n; i++) bp[i] = (uint16) v[i]; if (!TIFFWriteShortArray(tif, type, tag, dir, n, (uint16*)bp)) goto out; } break; case TIFF_SSHORT: { int16* bp = (int16*) w; for (i = 0; i < (int) n; i++) bp[i] = (int16) v[i]; if (!TIFFWriteShortArray(tif, type, tag, dir, n, (uint16*)bp)) goto out; } break; case TIFF_LONG: { uint32* bp = (uint32*) w; for (i = 0; i < (int) n; i++) bp[i] = (uint32) v[i]; if (!TIFFWriteLongArray(tif, type, tag, dir, n, bp)) goto out; } break; case TIFF_SLONG: { int32* bp = (int32*) w; for (i = 0; i < (int) n; i++) bp[i] = (int32) v[i]; if (!TIFFWriteLongArray(tif, type, tag, dir, n, (uint32*) bp)) goto out; } break; case TIFF_FLOAT: { float* bp = (float*) w; for (i = 0; i < (int) n; i++) bp[i] = (float) v[i]; if (!TIFFWriteFloatArray(tif, type, tag, dir, n, bp)) goto out; } break; case TIFF_DOUBLE: return (TIFFWriteDoubleArray(tif, type, tag, dir, n, v)); default: /* TIFF_NOTYPE */ /* TIFF_ASCII */ /* TIFF_UNDEFINED */ /* TIFF_RATIONAL */ /* TIFF_SRATIONAL */ goto out; } status = 1; out: if (w != buf) _TIFFfree(w); return (status); } #ifdef COLORIMETRY_SUPPORT static int TIFFWriteTransferFunction(TIFF* tif, TIFFDirEntry* dir) { TIFFDirectory* td = &tif->tif_dir; tsize_t n = (1L<td_bitspersample) * sizeof (uint16); uint16** tf = td->td_transferfunction; int ncols; /* * Check if the table can be written as a single column, * or if it must be written as 3 columns. Note that we * write a 3-column tag if there are 2 samples/pixel and * a single column of data won't suffice--hmm. */ switch (td->td_samplesperpixel - td->td_extrasamples) { default: if (_TIFFmemcmp(tf[0], tf[2], n)) { ncols = 3; break; } case 2: if (_TIFFmemcmp(tf[0], tf[1], n)) { ncols = 3; break; } case 1: case 0: ncols = 1; } return (TIFFWriteShortTable(tif, TIFFTAG_TRANSFERFUNCTION, dir, ncols, tf)); } #endif #ifdef CMYK_SUPPORT static int TIFFWriteInkNames(TIFF* tif, TIFFDirEntry* dir) { TIFFDirectory* td = &tif->tif_dir; dir->tdir_tag = TIFFTAG_INKNAMES; dir->tdir_type = (short) TIFF_ASCII; dir->tdir_count = td->td_inknameslen; return (TIFFWriteByteArray(tif, dir, td->td_inknames)); } #endif /* * Write a contiguous directory item. */ static int TIFFWriteData(TIFF* tif, TIFFDirEntry* dir, char* cp) { tsize_t cc; if (tif->tif_flags & TIFF_SWAB) { switch (dir->tdir_type) { case TIFF_SHORT: case TIFF_SSHORT: TIFFSwabArrayOfShort((uint16*) cp, dir->tdir_count); break; case TIFF_LONG: case TIFF_SLONG: case TIFF_FLOAT: TIFFSwabArrayOfLong((uint32*) cp, dir->tdir_count); break; case TIFF_RATIONAL: case TIFF_SRATIONAL: TIFFSwabArrayOfLong((uint32*) cp, 2*dir->tdir_count); break; case TIFF_DOUBLE: TIFFSwabArrayOfDouble((double*) cp, dir->tdir_count); break; } } dir->tdir_offset = tif->tif_dataoff; cc = dir->tdir_count * tiffDataWidth[dir->tdir_type]; if (SeekOK(tif, dir->tdir_offset) && WriteOK(tif, cp, cc)) { tif->tif_dataoff += (cc + 1) & ~1; return (1); } TIFFError(tif->tif_name, "Error writing data for field \"%s\"", _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name); return (0); } /* * Link the current directory into the * directory chain for the file. */ static int TIFFLinkDirectory(TIFF* tif) { static const char module[] = "TIFFLinkDirectory"; uint32 nextdir; uint32 diroff; tif->tif_diroff = (TIFFSeekFile(tif, (toff_t) 0, SEEK_END)+1) &~ 1; diroff = (uint32) tif->tif_diroff; if (tif->tif_flags & TIFF_SWAB) TIFFSwabLong(&diroff); #if SUBIFD_SUPPORT if (tif->tif_flags & TIFF_INSUBIFD) { (void) TIFFSeekFile(tif, tif->tif_subifdoff, SEEK_SET); if (!WriteOK(tif, &diroff, sizeof (diroff))) { TIFFError(module, "%s: Error writing SubIFD directory link", tif->tif_name); return (0); } /* * Advance to the next SubIFD or, if this is * the last one configured, revert back to the * normal directory linkage. */ if (--tif->tif_nsubifd) tif->tif_subifdoff += sizeof (diroff); else tif->tif_flags &= ~TIFF_INSUBIFD; return (1); } #endif if (tif->tif_header.tiff_diroff == 0) { /* * First directory, overwrite offset in header. */ tif->tif_header.tiff_diroff = (uint32) tif->tif_diroff; #define HDROFF(f) ((toff_t) &(((TIFFHeader*) 0)->f)) (void) TIFFSeekFile(tif, HDROFF(tiff_diroff), SEEK_SET); if (!WriteOK(tif, &diroff, sizeof (diroff))) { TIFFError(tif->tif_name, "Error writing TIFF header"); return (0); } return (1); } /* * Not the first directory, search to the last and append. */ nextdir = tif->tif_header.tiff_diroff; do { uint16 dircount; if (!SeekOK(tif, nextdir) || !ReadOK(tif, &dircount, sizeof (dircount))) { TIFFError(module, "Error fetching directory count"); return (0); } if (tif->tif_flags & TIFF_SWAB) TIFFSwabShort(&dircount); (void) TIFFSeekFile(tif, dircount * sizeof (TIFFDirEntry), SEEK_CUR); if (!ReadOK(tif, &nextdir, sizeof (nextdir))) { TIFFError(module, "Error fetching directory link"); return (0); } if (tif->tif_flags & TIFF_SWAB) TIFFSwabLong(&nextdir); } while (nextdir != 0); (void) TIFFSeekFile(tif, -(toff_t) sizeof (nextdir), SEEK_CUR); if (!WriteOK(tif, &diroff, sizeof (diroff))) { TIFFError(module, "Error writing directory link"); return (0); } return (1); } netpbm-8.2/libtiff/tif_dumpmode.c0100660000076400000000000000601506747424643016147 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_dumpmode.c,v 1.1.1.1 1999/07/27 21:50:27 mike Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library. * * "Null" Compression Algorithm Support. */ #include "tiffiop.h" /* * Encode a hunk of pixels. */ static int DumpModeEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s) { (void) s; while (cc > 0) { tsize_t n; n = cc; if (tif->tif_rawcc + n > tif->tif_rawdatasize) n = tif->tif_rawdatasize - tif->tif_rawcc; /* * Avoid copy if client has setup raw * data buffer to avoid extra copy. */ if (tif->tif_rawcp != pp) _TIFFmemcpy(tif->tif_rawcp, pp, n); tif->tif_rawcp += n; tif->tif_rawcc += n; pp += n; cc -= n; if (tif->tif_rawcc >= tif->tif_rawdatasize && !TIFFFlushData1(tif)) return (-1); } return (1); } /* * Decode a hunk of pixels. */ static int DumpModeDecode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) { (void) s; if (tif->tif_rawcc < cc) { TIFFError(tif->tif_name, "DumpModeDecode: Not enough data for scanline %d", tif->tif_row); return (0); } /* * Avoid copy if client has setup raw * data buffer to avoid extra copy. */ if (tif->tif_rawcp != buf) _TIFFmemcpy(buf, tif->tif_rawcp, cc); tif->tif_rawcp += cc; tif->tif_rawcc -= cc; return (1); } /* * Seek forwards nrows in the current strip. */ static int DumpModeSeek(TIFF* tif, uint32 nrows) { tif->tif_rawcp += nrows * tif->tif_scanlinesize; tif->tif_rawcc -= nrows * tif->tif_scanlinesize; return (1); } /* * Initialize dump mode. */ int TIFFInitDumpMode(TIFF* tif, int scheme) { (void) scheme; tif->tif_decoderow = DumpModeDecode; tif->tif_decodestrip = DumpModeDecode; tif->tif_decodetile = DumpModeDecode; tif->tif_encoderow = DumpModeEncode; tif->tif_encodestrip = DumpModeEncode; tif->tif_encodetile = DumpModeEncode; tif->tif_seek = DumpModeSeek; return (1); } netpbm-8.2/libtiff/tif_error.c0100660000076400000000000000324306747424643015466 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_error.c,v 1.1.1.1 1999/07/27 21:50:27 mike Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library. */ #include "tiffiop.h" TIFFErrorHandler TIFFSetErrorHandler(TIFFErrorHandler handler) { TIFFErrorHandler prev = _TIFFerrorHandler; _TIFFerrorHandler = handler; return (prev); } void TIFFError(const char* module, const char* fmt, ...) { if (_TIFFerrorHandler) { va_list ap; va_start(ap, fmt); (*_TIFFerrorHandler)(module, fmt, ap); va_end(ap); } } netpbm-8.2/libtiff/tif_fax3.c0100660000076400000000000012310207020306550015150 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_fax3.c,v 1.6 1999/11/28 20:15:36 mwelles Exp $ */ /* * Copyright (c) 1990-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. */ #include "tiffiop.h" #ifdef CCITT_SUPPORT /* * TIFF Library. * * CCITT Group 3 (T.4) and Group 4 (T.6) Compression Support. * * This file contains support for decoding and encoding TIFF * compression algorithms 2, 3, 4, and 32771. * * Decoder support is derived, with permission, from the code * in Frank Cringle's viewfax program; * Copyright (C) 1990, 1995 Frank D. Cringle. */ #include "tif_fax3.h" #define G3CODES #include "t4.h" #include #include /* * NB: define PURIFY if you're using purify and you want * to avoid some harmless array bounds complaints that * can happen in the _TIFFFax3fillruns routine. */ /* * Compression+decompression state blocks are * derived from this ``base state'' block. */ typedef struct { int mode; /* operating mode */ uint32 rowbytes; /* bytes in a decoded scanline */ uint32 rowpixels; /* pixels in a scanline */ uint16 cleanfaxdata; /* CleanFaxData tag */ uint32 badfaxrun; /* BadFaxRun tag */ uint32 badfaxlines; /* BadFaxLines tag */ uint32 groupoptions; /* Group 3/4 options tag */ uint32 recvparams; /* encoded Class 2 session params */ char* subaddress; /* subaddress string */ uint32 recvtime; /* time spent receiving (secs) */ TIFFVGetMethod vgetparent; /* super-class method */ TIFFVSetMethod vsetparent; /* super-class method */ } Fax3BaseState; #define Fax3State(tif) ((Fax3BaseState*) (tif)->tif_data) typedef struct { Fax3BaseState b; const u_char* bitmap; /* bit reversal table */ uint32 data; /* current i/o byte/word */ int bit; /* current i/o bit in byte */ int EOLcnt; /* count of EOL codes recognized */ TIFFFaxFillFunc fill; /* fill routine */ uint32* runs; /* b&w runs for current/previous row */ uint32* refruns; /* runs for reference line */ uint32* curruns; /* runs for current line */ } Fax3DecodeState; #define DecoderState(tif) ((Fax3DecodeState*) Fax3State(tif)) typedef enum { G3_1D, G3_2D } Ttag; typedef struct { Fax3BaseState b; int data; /* current i/o byte */ int bit; /* current i/o bit in byte */ Ttag tag; /* encoding state */ u_char* refline; /* reference line for 2d decoding */ int k; /* #rows left that can be 2d encoded */ int maxk; /* max #rows that can be 2d encoded */ } Fax3EncodeState; #define EncoderState(tif) ((Fax3EncodeState*) Fax3State(tif)) #define is2DEncoding(sp) \ (sp->b.groupoptions & GROUP3OPT_2DENCODING) #define isAligned(p,t) ((((u_long)(p)) & (sizeof (t)-1)) == 0) /* * Group 3 and Group 4 Decoding. */ /* * These macros glue the TIFF library state to * the state expected by Frank's decoder. */ #define DECLARE_STATE(tif, sp, mod) \ static const char module[] = mod; \ Fax3DecodeState* sp = DecoderState(tif); \ int a0; /* reference element */ \ int lastx = sp->b.rowpixels; /* last element in row */ \ uint32 BitAcc; /* bit accumulator */ \ int BitsAvail; /* # valid bits in BitAcc */ \ int RunLength; /* length of current run */ \ u_char* cp; /* next byte of input data */ \ u_char* ep; /* end of input data */ \ uint32* pa; /* place to stuff next run */ \ uint32* thisrun; /* current row's run array */ \ int EOLcnt; /* # EOL codes recognized */ \ const u_char* bitmap = sp->bitmap; /* input data bit reverser */ \ const TIFFFaxTabEnt* TabEnt #define DECLARE_STATE_2D(tif, sp, mod) \ DECLARE_STATE(tif, sp, mod); \ int b1; /* next change on prev line */ \ uint32* pb /* next run in reference line */\ /* * Load any state that may be changed during decoding. */ #define CACHE_STATE(tif, sp) do { \ BitAcc = sp->data; \ BitsAvail = sp->bit; \ EOLcnt = sp->EOLcnt; \ cp = (unsigned char*) tif->tif_rawcp; \ ep = cp + tif->tif_rawcc; \ } while (0) /* * Save state possibly changed during decoding. */ #define UNCACHE_STATE(tif, sp) do { \ sp->bit = BitsAvail; \ sp->data = BitAcc; \ sp->EOLcnt = EOLcnt; \ tif->tif_rawcc -= (tidata_t) cp - tif->tif_rawcp; \ tif->tif_rawcp = (tidata_t) cp; \ } while (0) /* * Setup state for decoding a strip. */ static int Fax3PreDecode(TIFF* tif, tsample_t s) { Fax3DecodeState* sp = DecoderState(tif); (void) s; assert(sp != NULL); sp->bit = 0; /* force initial read */ sp->data = 0; sp->EOLcnt = 0; /* force initial scan for EOL */ /* * Decoder assumes lsb-to-msb bit order. Note that we select * this here rather than in Fax3SetupState so that viewers can * hold the image open, fiddle with the FillOrder tag value, * and then re-decode the image. Otherwise they'd need to close * and open the image to get the state reset. */ sp->bitmap = TIFFGetBitRevTable(tif->tif_dir.td_fillorder != FILLORDER_LSB2MSB); if (sp->refruns) { /* init reference line to white */ sp->refruns[0] = (uint16) sp->b.rowpixels; sp->refruns[1] = 0; } return (1); } /* * Routine for handling various errors/conditions. * Note how they are "glued into the decoder" by * overriding the definitions used by the decoder. */ static void Fax3Unexpected(const char* module, TIFF* tif, uint32 a0) { TIFFError(module, "%s: Bad code word at scanline %d (x %lu)", tif->tif_name, tif->tif_row, (u_long) a0); } #define unexpected(table, a0) Fax3Unexpected(module, tif, a0) static void Fax3Extension(const char* module, TIFF* tif, uint32 a0) { TIFFError(module, "%s: Uncompressed data (not supported) at scanline %d (x %lu)", tif->tif_name, tif->tif_row, (u_long) a0); } #define extension(a0) Fax3Extension(module, tif, a0) static void Fax3BadLength(const char* module, TIFF* tif, uint32 a0, uint32 lastx) { TIFFWarning(module, "%s: %s at scanline %d (got %lu, expected %lu)", tif->tif_name, a0 < lastx ? "Premature EOL" : "Line length mismatch", tif->tif_row, (u_long) a0, (u_long) lastx); } #define badlength(a0,lastx) Fax3BadLength(module, tif, a0, lastx) static void Fax3PrematureEOF(const char* module, TIFF* tif, uint32 a0) { TIFFWarning(module, "%s: Premature EOF at scanline %d (x %lu)", tif->tif_name, tif->tif_row, (u_long) a0); } #define prematureEOF(a0) Fax3PrematureEOF(module, tif, a0) #define Nop /* * Decode the requested amount of G3 1D-encoded data. */ static int Fax3Decode1D(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s) { DECLARE_STATE(tif, sp, "Fax3Decode1D"); (void) s; CACHE_STATE(tif, sp); thisrun = sp->curruns; while ((long)occ > 0) { a0 = 0; RunLength = 0; pa = thisrun; #ifdef FAX3_DEBUG printf("\nBitAcc=%08X, BitsAvail = %d\n", BitAcc, BitsAvail); printf("-------------------- %d\n", tif->tif_row); fflush(stdout); #endif SYNC_EOL(EOF1D); EXPAND1D(EOF1Da); (*sp->fill)(buf, thisrun, pa, lastx); buf += sp->b.rowbytes; occ -= sp->b.rowbytes; if (occ != 0) tif->tif_row++; continue; EOF1D: /* premature EOF */ CLEANUP_RUNS(); EOF1Da: /* premature EOF */ (*sp->fill)(buf, thisrun, pa, lastx); UNCACHE_STATE(tif, sp); return (-1); } UNCACHE_STATE(tif, sp); return (1); } #define SWAP(t,a,b) { t x; x = (a); (a) = (b); (b) = x; } /* * Decode the requested amount of G3 2D-encoded data. */ static int Fax3Decode2D(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s) { DECLARE_STATE_2D(tif, sp, "Fax3Decode2D"); int is1D; /* current line is 1d/2d-encoded */ (void) s; CACHE_STATE(tif, sp); while ((long)occ > 0) { a0 = 0; RunLength = 0; pa = thisrun = sp->curruns; #ifdef FAX3_DEBUG printf("\nBitAcc=%08X, BitsAvail = %d EOLcnt = %d", BitAcc, BitsAvail, EOLcnt); #endif SYNC_EOL(EOF2D); NeedBits8(1, EOF2D); is1D = GetBits(1); /* 1D/2D-encoding tag bit */ ClrBits(1); #ifdef FAX3_DEBUG printf(" %s\n-------------------- %d\n", is1D ? "1D" : "2D", tif->tif_row); fflush(stdout); #endif pb = sp->refruns; b1 = *pb++; if (is1D) EXPAND1D(EOF2Da); else EXPAND2D(EOF2Da); (*sp->fill)(buf, thisrun, pa, lastx); SETVAL(0); /* imaginary change for reference */ SWAP(uint32*, sp->curruns, sp->refruns); buf += sp->b.rowbytes; occ -= sp->b.rowbytes; if (occ != 0) tif->tif_row++; continue; EOF2D: /* premature EOF */ CLEANUP_RUNS(); EOF2Da: /* premature EOF */ (*sp->fill)(buf, thisrun, pa, lastx); UNCACHE_STATE(tif, sp); return (-1); } UNCACHE_STATE(tif, sp); return (1); } #undef SWAP /* * The ZERO & FILL macros must handle spans < 2*sizeof(long) bytes. * For machines with 64-bit longs this is <16 bytes; otherwise * this is <8 bytes. We optimize the code here to reflect the * machine characteristics. */ #if defined(__alpha) || _MIPS_SZLONG == 64 #define FILL(n, cp) \ switch (n) { \ case 15:(cp)[14] = 0xff; case 14:(cp)[13] = 0xff; case 13: (cp)[12] = 0xff;\ case 12:(cp)[11] = 0xff; case 11:(cp)[10] = 0xff; case 10: (cp)[9] = 0xff;\ case 9: (cp)[8] = 0xff; case 8: (cp)[7] = 0xff; case 7: (cp)[6] = 0xff;\ case 6: (cp)[5] = 0xff; case 5: (cp)[4] = 0xff; case 4: (cp)[3] = 0xff;\ case 3: (cp)[2] = 0xff; case 2: (cp)[1] = 0xff; \ case 1: (cp)[0] = 0xff; (cp) += (n); case 0: ; \ } #define ZERO(n, cp) \ switch (n) { \ case 15:(cp)[14] = 0; case 14:(cp)[13] = 0; case 13: (cp)[12] = 0; \ case 12:(cp)[11] = 0; case 11:(cp)[10] = 0; case 10: (cp)[9] = 0; \ case 9: (cp)[8] = 0; case 8: (cp)[7] = 0; case 7: (cp)[6] = 0; \ case 6: (cp)[5] = 0; case 5: (cp)[4] = 0; case 4: (cp)[3] = 0; \ case 3: (cp)[2] = 0; case 2: (cp)[1] = 0; \ case 1: (cp)[0] = 0; (cp) += (n); case 0: ; \ } #else #define FILL(n, cp) \ switch (n) { \ case 7: (cp)[6] = 0xff; case 6: (cp)[5] = 0xff; case 5: (cp)[4] = 0xff; \ case 4: (cp)[3] = 0xff; case 3: (cp)[2] = 0xff; case 2: (cp)[1] = 0xff; \ case 1: (cp)[0] = 0xff; (cp) += (n); case 0: ; \ } #define ZERO(n, cp) \ switch (n) { \ case 7: (cp)[6] = 0; case 6: (cp)[5] = 0; case 5: (cp)[4] = 0; \ case 4: (cp)[3] = 0; case 3: (cp)[2] = 0; case 2: (cp)[1] = 0; \ case 1: (cp)[0] = 0; (cp) += (n); case 0: ; \ } #endif /* * Bit-fill a row according to the white/black * runs generated during G3/G4 decoding. */ void _TIFFFax3fillruns(u_char* buf, uint32* runs, uint32* erun, uint32 lastx) { static const unsigned char _fillmasks[] = { 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff }; u_char* cp; uint32 x, bx, run; int32 n, nw; long* lp; if ((erun-runs)&1) *erun++ = 0; x = 0; for (; runs < erun; runs += 2) { run = runs[0]; if (x+run > lastx) run = runs[0] = (uint16) (lastx - x); if (run) { cp = buf + (x>>3); bx = x&7; if (run > 8-bx) { if (bx) { /* align to byte boundary */ *cp++ &= 0xff << (8-bx); run -= 8-bx; } if( (n = run >> 3) != 0 ) { /* multiple bytes to fill */ if ((n/sizeof (long)) > 1) { /* * Align to longword boundary and fill. */ for (; n && !isAligned(cp, long); n--) *cp++ = 0x00; lp = (long*) cp; nw = (int32)(n / sizeof (long)); n -= nw * sizeof (long); do { *lp++ = 0L; } while (--nw); cp = (u_char*) lp; } ZERO(n, cp); run &= 7; } #ifdef PURIFY if (run) cp[0] &= 0xff >> run; #else cp[0] &= 0xff >> run; #endif } else cp[0] &= ~(_fillmasks[run]>>bx); x += runs[0]; } run = runs[1]; if (x+run > lastx) run = runs[1] = lastx - x; if (run) { cp = buf + (x>>3); bx = x&7; if (run > 8-bx) { if (bx) { /* align to byte boundary */ *cp++ |= 0xff >> bx; run -= 8-bx; } if( (n = run>>3) != 0 ) { /* multiple bytes to fill */ if ((n/sizeof (long)) > 1) { /* * Align to longword boundary and fill. */ for (; n && !isAligned(cp, long); n--) *cp++ = 0xff; lp = (long*) cp; nw = (int32)(n / sizeof (long)); n -= nw * sizeof (long); do { *lp++ = -1L; } while (--nw); cp = (u_char*) lp; } FILL(n, cp); run &= 7; } #ifdef PURIFY if (run) cp[0] |= 0xff00 >> run; #else cp[0] |= 0xff00 >> run; #endif } else cp[0] |= _fillmasks[run]>>bx; x += runs[1]; } } assert(x == lastx); } #undef ZERO #undef FILL /* * Setup G3/G4-related compression/decompression state * before data is processed. This routine is called once * per image -- it sets up different state based on whether * or not decoding or encoding is being done and whether * 1D- or 2D-encoded data is involved. */ static int Fax3SetupState(TIFF* tif) { TIFFDirectory* td = &tif->tif_dir; Fax3BaseState* sp = Fax3State(tif); long rowbytes, rowpixels; int needsRefLine; if (td->td_bitspersample != 1) { TIFFError(tif->tif_name, "Bits/sample must be 1 for Group 3/4 encoding/decoding"); return (0); } /* * Calculate the scanline/tile widths. */ if (isTiled(tif)) { rowbytes = TIFFTileRowSize(tif); rowpixels = td->td_tilewidth; } else { rowbytes = TIFFScanlineSize(tif); rowpixels = td->td_imagewidth; } sp->rowbytes = (uint32) rowbytes; sp->rowpixels = (uint32) rowpixels; /* * Allocate any additional space required for decoding/encoding. */ needsRefLine = ( (sp->groupoptions & GROUP3OPT_2DENCODING) || td->td_compression == COMPRESSION_CCITTFAX4 ); if (tif->tif_mode == O_RDONLY) { /* 1d/2d decoding */ Fax3DecodeState* dsp = DecoderState(tif); uint32 nruns = needsRefLine ? 2*TIFFroundup(rowpixels,32) : rowpixels; dsp->runs = (uint32*) _TIFFmalloc(nruns*sizeof (uint32)); if (dsp->runs == NULL) { TIFFError("Fax3SetupState", "%s: No space for Group 3/4 run arrays", tif->tif_name); return (0); } dsp->curruns = dsp->runs; if (needsRefLine) dsp->refruns = dsp->runs + (nruns>>1); else dsp->refruns = NULL; if (is2DEncoding(dsp)) { /* NB: default is 1D routine */ tif->tif_decoderow = Fax3Decode2D; tif->tif_decodestrip = Fax3Decode2D; tif->tif_decodetile = Fax3Decode2D; } } else if (needsRefLine) { /* 2d encoding */ Fax3EncodeState* esp = EncoderState(tif); /* * 2d encoding requires a scanline * buffer for the ``reference line''; the * scanline against which delta encoding * is referenced. The reference line must * be initialized to be ``white'' (done elsewhere). */ esp->refline = (u_char*) _TIFFmalloc(rowbytes); if (esp->refline == NULL) { TIFFError("Fax3SetupState", "%s: No space for Group 3/4 reference line", tif->tif_name); return (0); } } else /* 1d encoding */ EncoderState(tif)->refline = NULL; return (1); } /* * CCITT Group 3 FAX Encoding. */ #define Fax3FlushBits(tif, sp) { \ if ((tif)->tif_rawcc >= (tif)->tif_rawdatasize) \ (void) TIFFFlushData1(tif); \ *(tif)->tif_rawcp++ = (sp)->data; \ (tif)->tif_rawcc++; \ (sp)->data = 0, (sp)->bit = 8; \ } #define _FlushBits(tif) { \ if ((tif)->tif_rawcc >= (tif)->tif_rawdatasize) \ (void) TIFFFlushData1(tif); \ *(tif)->tif_rawcp++ = data; \ (tif)->tif_rawcc++; \ data = 0, bit = 8; \ } static const int _msbmask[9] = { 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff }; #define _PutBits(tif, bits, length) { \ while (length > bit) { \ data |= bits >> (length - bit); \ length -= bit; \ _FlushBits(tif); \ } \ data |= (bits & _msbmask[length]) << (bit - length); \ bit -= length; \ if (bit == 0) \ _FlushBits(tif); \ } /* * Write a variable-length bit-value to * the output stream. Values are * assumed to be at most 16 bits. */ static void Fax3PutBits(TIFF* tif, u_int bits, u_int length) { Fax3EncodeState* sp = EncoderState(tif); u_int bit = sp->bit; int data = sp->data; _PutBits(tif, bits, length); sp->data = data; sp->bit = bit; } /* * Write a code to the output stream. */ #define putcode(tif, te) Fax3PutBits(tif, (te)->code, (te)->length) #ifdef FAX3_DEBUG #define DEBUG_COLOR(w) (tab == TIFFFaxWhiteCodes ? w "W" : w "B") #define DEBUG_PRINT(what,len) { \ int t; \ printf("%08X/%-2d: %s%5d\t", data, bit, DEBUG_COLOR(what), len); \ for (t = length-1; t >= 0; t--) \ putchar(code & (1<bit; int data = sp->data; u_int code, length; while (span >= 2624) { const tableentry* te = &tab[63 + (2560>>6)]; code = te->code, length = te->length; #ifdef FAX3_DEBUG DEBUG_PRINT("MakeUp", te->runlen); #endif _PutBits(tif, code, length); span -= te->runlen; } if (span >= 64) { const tableentry* te = &tab[63 + (span>>6)]; assert(te->runlen == 64*(span>>6)); code = te->code, length = te->length; #ifdef FAX3_DEBUG DEBUG_PRINT("MakeUp", te->runlen); #endif _PutBits(tif, code, length); span -= te->runlen; } code = tab[span].code, length = tab[span].length; #ifdef FAX3_DEBUG DEBUG_PRINT(" Term", tab[span].runlen); #endif _PutBits(tif, code, length); sp->data = data; sp->bit = bit; } /* * Write an EOL code to the output stream. The zero-fill * logic for byte-aligning encoded scanlines is handled * here. We also handle writing the tag bit for the next * scanline when doing 2d encoding. */ static void Fax3PutEOL(TIFF* tif) { Fax3EncodeState* sp = EncoderState(tif); u_int bit = sp->bit; int data = sp->data; u_int code, length, tparm; if (sp->b.groupoptions & GROUP3OPT_FILLBITS) { /* * Force bit alignment so EOL will terminate on * a byte boundary. That is, force the bit alignment * to 16-12 = 4 before putting out the EOL code. */ int align = 8 - 4; if (align != sp->bit) { if (align > sp->bit) align = sp->bit + (8 - align); else align = sp->bit - align; code = 0; tparm=align; _PutBits(tif, 0, tparm); } } code = EOL, length = 12; if (is2DEncoding(sp)) code = (code<<1) | (sp->tag == G3_1D), length++; _PutBits(tif, code, length); sp->data = data; sp->bit = bit; } /* * Reset encoding state at the start of a strip. */ static int Fax3PreEncode(TIFF* tif, tsample_t s) { Fax3EncodeState* sp = EncoderState(tif); (void) s; assert(sp != NULL); sp->bit = 8; sp->data = 0; sp->tag = G3_1D; /* * This is necessary for Group 4; otherwise it isn't * needed because the first scanline of each strip ends * up being copied into the refline. */ if (sp->refline) _TIFFmemset(sp->refline, 0x00, sp->b.rowbytes); if (is2DEncoding(sp)) { float res = tif->tif_dir.td_yresolution; /* * The CCITT spec says that when doing 2d encoding, you * should only do it on K consecutive scanlines, where K * depends on the resolution of the image being encoded * (2 for <= 200 lpi, 4 for > 200 lpi). Since the directory * code initializes td_yresolution to 0, this code will * select a K of 2 unless the YResolution tag is set * appropriately. (Note also that we fudge a little here * and use 150 lpi to avoid problems with units conversion.) */ if (tif->tif_dir.td_resolutionunit == RESUNIT_CENTIMETER) res *= 2.54f; /* convert to inches */ sp->maxk = (res > 150 ? 4 : 2); sp->k = sp->maxk-1; } else sp->k = sp->maxk = 0; return (1); } static const u_char zeroruns[256] = { 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, /* 0x00 - 0x0f */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* 0x10 - 0x1f */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0x20 - 0x2f */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0x30 - 0x3f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x40 - 0x4f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x50 - 0x5f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x60 - 0x6f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x70 - 0x7f */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x80 - 0x8f */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x90 - 0x9f */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xa0 - 0xaf */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xb0 - 0xbf */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xc0 - 0xcf */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xd0 - 0xdf */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xe0 - 0xef */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xf0 - 0xff */ }; static const u_char oneruns[256] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x00 - 0x0f */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10 - 0x1f */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x20 - 0x2f */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x30 - 0x3f */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x40 - 0x4f */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x50 - 0x5f */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x60 - 0x6f */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x70 - 0x7f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x80 - 0x8f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x90 - 0x9f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0xa0 - 0xaf */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0xb0 - 0xbf */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0xc0 - 0xcf */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0xd0 - 0xdf */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* 0xe0 - 0xef */ 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 7, 8, /* 0xf0 - 0xff */ }; /* * On certain systems it pays to inline * the routines that find pixel spans. */ #ifdef VAXC static int32 find0span(u_char*, int32, int32); static int32 find1span(u_char*, int32, int32); #pragma inline(find0span,find1span) #endif /* * Find a span of ones or zeros using the supplied * table. The ``base'' of the bit string is supplied * along with the start+end bit indices. */ INLINE static int32 find0span(u_char* bp, int32 bs, int32 be) { int32 bits = be - bs; int32 n, span; bp += bs>>3; /* * Check partial byte on lhs. */ if (bits > 0 && (n = (bs & 7))) { span = zeroruns[(*bp << n) & 0xff]; if (span > 8-n) /* table value too generous */ span = 8-n; if (span > bits) /* constrain span to bit range */ span = bits; if (n+span < 8) /* doesn't extend to edge of byte */ return (span); bits -= span; bp++; } else span = 0; if (bits >= 2*8*sizeof (long)) { long* lp; /* * Align to longword boundary and check longwords. */ while (!isAligned(bp, long)) { if (*bp != 0x00) return (span + zeroruns[*bp]); span += 8, bits -= 8; bp++; } lp = (long*) bp; while (bits >= 8*sizeof (long) && *lp == 0) { span += 8*sizeof (long), bits -= 8*sizeof (long); lp++; } bp = (u_char*) lp; } /* * Scan full bytes for all 0's. */ while (bits >= 8) { if (*bp != 0x00) /* end of run */ return (span + zeroruns[*bp]); span += 8, bits -= 8; bp++; } /* * Check partial byte on rhs. */ if (bits > 0) { n = zeroruns[*bp]; span += (n > bits ? bits : n); } return (span); } INLINE static int32 find1span(u_char* bp, int32 bs, int32 be) { int32 bits = be - bs; int32 n, span; bp += bs>>3; /* * Check partial byte on lhs. */ if (bits > 0 && (n = (bs & 7))) { span = oneruns[(*bp << n) & 0xff]; if (span > 8-n) /* table value too generous */ span = 8-n; if (span > bits) /* constrain span to bit range */ span = bits; if (n+span < 8) /* doesn't extend to edge of byte */ return (span); bits -= span; bp++; } else span = 0; if (bits >= 2*8*sizeof (long)) { long* lp; /* * Align to longword boundary and check longwords. */ while (!isAligned(bp, long)) { if (*bp != 0xff) return (span + oneruns[*bp]); span += 8, bits -= 8; bp++; } lp = (long*) bp; while (bits >= 8*sizeof (long) && *lp == ~0) { span += 8*sizeof (long), bits -= 8*sizeof (long); lp++; } bp = (u_char*) lp; } /* * Scan full bytes for all 1's. */ while (bits >= 8) { if (*bp != 0xff) /* end of run */ return (span + oneruns[*bp]); span += 8, bits -= 8; bp++; } /* * Check partial byte on rhs. */ if (bits > 0) { n = oneruns[*bp]; span += (n > bits ? bits : n); } return (span); } /* * Return the offset of the next bit in the range * [bs..be] that is different from the specified * color. The end, be, is returned if no such bit * exists. */ #define finddiff(_cp, _bs, _be, _color) \ (_bs + (_color ? find1span(_cp,_bs,_be) : find0span(_cp,_bs,_be))) /* * Like finddiff, but also check the starting bit * against the end in case start > end. */ #define finddiff2(_cp, _bs, _be, _color) \ (_bs < _be ? finddiff(_cp,_bs,_be,_color) : _be) /* * 1d-encode a row of pixels. The encoding is * a sequence of all-white or all-black spans * of pixels encoded with Huffman codes. */ static int Fax3Encode1DRow(TIFF* tif, u_char* bp, uint32 bits) { Fax3EncodeState* sp = EncoderState(tif); int32 span; uint32 bs = 0; for (;;) { span = find0span(bp, bs, bits); /* white span */ putspan(tif, span, TIFFFaxWhiteCodes); bs += span; if (bs >= bits) break; span = find1span(bp, bs, bits); /* black span */ putspan(tif, span, TIFFFaxBlackCodes); bs += span; if (bs >= bits) break; } if (sp->b.mode & (FAXMODE_BYTEALIGN|FAXMODE_WORDALIGN)) { if (sp->bit != 8) /* byte-align */ Fax3FlushBits(tif, sp); if ((sp->b.mode&FAXMODE_WORDALIGN) && !isAligned(tif->tif_rawcp, uint16)) Fax3FlushBits(tif, sp); } return (1); } static const tableentry horizcode = { 3, 0x1 }; /* 001 */ static const tableentry passcode = { 4, 0x1 }; /* 0001 */ static const tableentry vcodes[7] = { { 7, 0x03 }, /* 0000 011 */ { 6, 0x03 }, /* 0000 11 */ { 3, 0x03 }, /* 011 */ { 1, 0x1 }, /* 1 */ { 3, 0x2 }, /* 010 */ { 6, 0x02 }, /* 0000 10 */ { 7, 0x02 } /* 0000 010 */ }; /* * 2d-encode a row of pixels. Consult the CCITT * documentation for the algorithm. */ static int Fax3Encode2DRow(TIFF* tif, u_char* bp, u_char* rp, uint32 bits) { #define PIXEL(buf,ix) ((((buf)[(ix)>>3]) >> (7-((ix)&7))) & 1) uint32 a0 = 0; uint32 a1 = (PIXEL(bp, 0) != 0 ? 0 : finddiff(bp, 0, bits, 0)); uint32 b1 = (PIXEL(rp, 0) != 0 ? 0 : finddiff(rp, 0, bits, 0)); uint32 a2, b2; for (;;) { b2 = finddiff2(rp, b1, bits, PIXEL(rp,b1)); if (b2 >= a1) { int32 d = b1 - a1; if (!(-3 <= d && d <= 3)) { /* horizontal mode */ a2 = finddiff2(bp, a1, bits, PIXEL(bp,a1)); putcode(tif, &horizcode); if (a0+a1 == 0 || PIXEL(bp, a0) == 0) { putspan(tif, a1-a0, TIFFFaxWhiteCodes); putspan(tif, a2-a1, TIFFFaxBlackCodes); } else { putspan(tif, a1-a0, TIFFFaxBlackCodes); putspan(tif, a2-a1, TIFFFaxWhiteCodes); } a0 = a2; } else { /* vertical mode */ putcode(tif, &vcodes[d+3]); a0 = a1; } } else { /* pass mode */ putcode(tif, &passcode); a0 = b2; } if (a0 >= bits) break; a1 = finddiff(bp, a0, bits, PIXEL(bp,a0)); b1 = finddiff(rp, a0, bits, !PIXEL(bp,a0)); b1 = finddiff(rp, b1, bits, PIXEL(bp,a0)); } return (1); #undef PIXEL } /* * Encode a buffer of pixels. */ static int Fax3Encode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) { Fax3EncodeState* sp = EncoderState(tif); (void) s; while ((long)cc > 0) { if ((sp->b.mode & FAXMODE_NOEOL) == 0) Fax3PutEOL(tif); if (is2DEncoding(sp)) { if (sp->tag == G3_1D) { if (!Fax3Encode1DRow(tif, bp, sp->b.rowpixels)) return (0); sp->tag = G3_2D; } else { if (!Fax3Encode2DRow(tif, bp, sp->refline, sp->b.rowpixels)) return (0); sp->k--; } if (sp->k == 0) { sp->tag = G3_1D; sp->k = sp->maxk-1; } else _TIFFmemcpy(sp->refline, bp, sp->b.rowbytes); } else { if (!Fax3Encode1DRow(tif, bp, sp->b.rowpixels)) return (0); } bp += sp->b.rowbytes; cc -= sp->b.rowbytes; if (cc != 0) tif->tif_row++; } return (1); } static int Fax3PostEncode(TIFF* tif) { Fax3EncodeState* sp = EncoderState(tif); if (sp->bit != 8) Fax3FlushBits(tif, sp); return (1); } static void Fax3Close(TIFF* tif) { if ((Fax3State(tif)->mode & FAXMODE_NORTC) == 0) { Fax3EncodeState* sp = EncoderState(tif); u_int code = EOL; u_int length = 12; int i; if (is2DEncoding(sp)) code = (code<<1) | (sp->tag == G3_1D), length++; for (i = 0; i < 6; i++) Fax3PutBits(tif, code, length); Fax3FlushBits(tif, sp); } } static void Fax3Cleanup(TIFF* tif) { if (tif->tif_data) { if (tif->tif_mode == O_RDONLY) { Fax3DecodeState* sp = DecoderState(tif); if (sp->runs) _TIFFfree(sp->runs); } else { Fax3EncodeState* sp = EncoderState(tif); if (sp->refline) _TIFFfree(sp->refline); } if (Fax3State(tif)->subaddress) _TIFFfree(Fax3State(tif)->subaddress); _TIFFfree(tif->tif_data); tif->tif_data = NULL; } } #define FIELD_BADFAXLINES (FIELD_CODEC+0) #define FIELD_CLEANFAXDATA (FIELD_CODEC+1) #define FIELD_BADFAXRUN (FIELD_CODEC+2) #define FIELD_RECVPARAMS (FIELD_CODEC+3) #define FIELD_SUBADDRESS (FIELD_CODEC+4) #define FIELD_RECVTIME (FIELD_CODEC+5) #define FIELD_OPTIONS (FIELD_CODEC+6) static const TIFFFieldInfo faxFieldInfo[] = { { TIFFTAG_FAXMODE, 0, 0, TIFF_ANY, FIELD_PSEUDO, FALSE, FALSE, "FaxMode" }, { TIFFTAG_FAXFILLFUNC, 0, 0, TIFF_ANY, FIELD_PSEUDO, FALSE, FALSE, "FaxFillFunc" }, { TIFFTAG_BADFAXLINES, 1, 1, TIFF_LONG, FIELD_BADFAXLINES, TRUE, FALSE, "BadFaxLines" }, { TIFFTAG_BADFAXLINES, 1, 1, TIFF_SHORT, FIELD_BADFAXLINES, TRUE, FALSE, "BadFaxLines" }, { TIFFTAG_CLEANFAXDATA, 1, 1, TIFF_SHORT, FIELD_CLEANFAXDATA, TRUE, FALSE, "CleanFaxData" }, { TIFFTAG_CONSECUTIVEBADFAXLINES,1,1, TIFF_LONG, FIELD_BADFAXRUN, TRUE, FALSE, "ConsecutiveBadFaxLines" }, { TIFFTAG_CONSECUTIVEBADFAXLINES,1,1, TIFF_SHORT, FIELD_BADFAXRUN, TRUE, FALSE, "ConsecutiveBadFaxLines" }, { TIFFTAG_FAXRECVPARAMS, 1, 1, TIFF_LONG, FIELD_RECVPARAMS, TRUE, FALSE, "FaxRecvParams" }, { TIFFTAG_FAXSUBADDRESS, -1,-1, TIFF_ASCII, FIELD_SUBADDRESS, TRUE, FALSE, "FaxSubAddress" }, { TIFFTAG_FAXRECVTIME, 1, 1, TIFF_LONG, FIELD_RECVTIME, TRUE, FALSE, "FaxRecvTime" }, }; static const TIFFFieldInfo fax3FieldInfo[] = { { TIFFTAG_GROUP3OPTIONS, 1, 1, TIFF_LONG, FIELD_OPTIONS, FALSE, FALSE, "Group3Options" }, }; static const TIFFFieldInfo fax4FieldInfo[] = { { TIFFTAG_GROUP4OPTIONS, 1, 1, TIFF_LONG, FIELD_OPTIONS, FALSE, FALSE, "Group4Options" }, }; #define N(a) (sizeof (a) / sizeof (a[0])) static int Fax3VSetField(TIFF* tif, ttag_t tag, va_list ap) { Fax3BaseState* sp = Fax3State(tif); switch (tag) { case TIFFTAG_FAXMODE: sp->mode = va_arg(ap, int); return (1); /* NB: pseudo tag */ case TIFFTAG_FAXFILLFUNC: if (tif->tif_mode == O_RDONLY) DecoderState(tif)->fill = va_arg(ap, TIFFFaxFillFunc); return (1); /* NB: pseudo tag */ case TIFFTAG_GROUP3OPTIONS: case TIFFTAG_GROUP4OPTIONS: sp->groupoptions = va_arg(ap, uint32); break; case TIFFTAG_BADFAXLINES: sp->badfaxlines = va_arg(ap, uint32); break; case TIFFTAG_CLEANFAXDATA: sp->cleanfaxdata = (uint16) va_arg(ap, int); break; case TIFFTAG_CONSECUTIVEBADFAXLINES: sp->badfaxrun = va_arg(ap, uint32); break; case TIFFTAG_FAXRECVPARAMS: sp->recvparams = va_arg(ap, uint32); break; case TIFFTAG_FAXSUBADDRESS: _TIFFsetString(&sp->subaddress, va_arg(ap, char*)); break; case TIFFTAG_FAXRECVTIME: sp->recvtime = va_arg(ap, uint32); break; default: return (*sp->vsetparent)(tif, tag, ap); } TIFFSetFieldBit(tif, _TIFFFieldWithTag(tif, tag)->field_bit); tif->tif_flags |= TIFF_DIRTYDIRECT; return (1); } static int Fax3VGetField(TIFF* tif, ttag_t tag, va_list ap) { Fax3BaseState* sp = Fax3State(tif); switch (tag) { case TIFFTAG_FAXMODE: *va_arg(ap, int*) = sp->mode; break; case TIFFTAG_FAXFILLFUNC: if (tif->tif_mode == O_RDONLY) *va_arg(ap, TIFFFaxFillFunc*) = DecoderState(tif)->fill; break; case TIFFTAG_GROUP3OPTIONS: case TIFFTAG_GROUP4OPTIONS: *va_arg(ap, uint32*) = sp->groupoptions; break; case TIFFTAG_BADFAXLINES: *va_arg(ap, uint32*) = sp->badfaxlines; break; case TIFFTAG_CLEANFAXDATA: *va_arg(ap, uint16*) = sp->cleanfaxdata; break; case TIFFTAG_CONSECUTIVEBADFAXLINES: *va_arg(ap, uint32*) = sp->badfaxrun; break; case TIFFTAG_FAXRECVPARAMS: *va_arg(ap, uint32*) = sp->recvparams; break; case TIFFTAG_FAXSUBADDRESS: *va_arg(ap, char**) = sp->subaddress; break; case TIFFTAG_FAXRECVTIME: *va_arg(ap, uint32*) = sp->recvtime; break; default: return (*sp->vgetparent)(tif, tag, ap); } return (1); } static void Fax3PrintDir(TIFF* tif, FILE* fd, long flags) { Fax3BaseState* sp = Fax3State(tif); (void) flags; if (TIFFFieldSet(tif,FIELD_OPTIONS)) { const char* sep = " "; if (tif->tif_dir.td_compression == COMPRESSION_CCITTFAX4) { fprintf(fd, " Group 4 Options:"); if (sp->groupoptions & GROUP4OPT_UNCOMPRESSED) fprintf(fd, "%suncompressed data", sep); } else { fprintf(fd, " Group 3 Options:"); if (sp->groupoptions & GROUP3OPT_2DENCODING) fprintf(fd, "%s2-d encoding", sep), sep = "+"; if (sp->groupoptions & GROUP3OPT_FILLBITS) fprintf(fd, "%sEOL padding", sep), sep = "+"; if (sp->groupoptions & GROUP3OPT_UNCOMPRESSED) fprintf(fd, "%suncompressed data", sep); } fprintf(fd, " (%lu = 0x%lx)\n", (u_long) sp->groupoptions, (u_long) sp->groupoptions); } if (TIFFFieldSet(tif,FIELD_CLEANFAXDATA)) { fprintf(fd, " Fax Data:"); switch (sp->cleanfaxdata) { case CLEANFAXDATA_CLEAN: fprintf(fd, " clean"); break; case CLEANFAXDATA_REGENERATED: fprintf(fd, " receiver regenerated"); break; case CLEANFAXDATA_UNCLEAN: fprintf(fd, " uncorrected errors"); break; } fprintf(fd, " (%u = 0x%x)\n", sp->cleanfaxdata, sp->cleanfaxdata); } if (TIFFFieldSet(tif,FIELD_BADFAXLINES)) fprintf(fd, " Bad Fax Lines: %lu\n", (u_long) sp->badfaxlines); if (TIFFFieldSet(tif,FIELD_BADFAXRUN)) fprintf(fd, " Consecutive Bad Fax Lines: %lu\n", (u_long) sp->badfaxrun); if (TIFFFieldSet(tif,FIELD_RECVPARAMS)) fprintf(fd, " Fax Receive Parameters: %08lx\n", (u_long) sp->recvparams); if (TIFFFieldSet(tif,FIELD_SUBADDRESS)) fprintf(fd, " Fax SubAddress: %s\n", sp->subaddress); if (TIFFFieldSet(tif,FIELD_RECVTIME)) fprintf(fd, " Fax Receive Time: %lu secs\n", (u_long) sp->recvtime); } static int InitCCITTFax3(TIFF* tif) { Fax3BaseState* sp; /* * Allocate state block so tag methods have storage to record values. */ if (tif->tif_mode == O_RDONLY) tif->tif_data = (tidata_t) _TIFFmalloc(sizeof (Fax3DecodeState)); else tif->tif_data = (tidata_t) _TIFFmalloc(sizeof (Fax3EncodeState)); if (tif->tif_data == NULL) { TIFFError("TIFFInitCCITTFax3", "%s: No space for state block", tif->tif_name); return (0); } sp = Fax3State(tif); /* * Merge codec-specific tag information and * override parent get/set field methods. */ _TIFFMergeFieldInfo(tif, faxFieldInfo, N(faxFieldInfo)); sp->vgetparent = tif->tif_vgetfield; tif->tif_vgetfield = Fax3VGetField; /* hook for codec tags */ sp->vsetparent = tif->tif_vsetfield; tif->tif_vsetfield = Fax3VSetField; /* hook for codec tags */ tif->tif_printdir = Fax3PrintDir; /* hook for codec tags */ sp->groupoptions = 0; sp->recvparams = 0; sp->subaddress = NULL; if (tif->tif_mode == O_RDONLY) { tif->tif_flags |= TIFF_NOBITREV;/* decoder does bit reversal */ DecoderState(tif)->runs = NULL; TIFFSetField(tif, TIFFTAG_FAXFILLFUNC, _TIFFFax3fillruns); } else EncoderState(tif)->refline = NULL; /* * Install codec methods. */ tif->tif_setupdecode = Fax3SetupState; tif->tif_predecode = Fax3PreDecode; tif->tif_decoderow = Fax3Decode1D; tif->tif_decodestrip = Fax3Decode1D; tif->tif_decodetile = Fax3Decode1D; tif->tif_setupencode = Fax3SetupState; tif->tif_preencode = Fax3PreEncode; tif->tif_postencode = Fax3PostEncode; tif->tif_encoderow = Fax3Encode; tif->tif_encodestrip = Fax3Encode; tif->tif_encodetile = Fax3Encode; tif->tif_close = Fax3Close; tif->tif_cleanup = Fax3Cleanup; return (1); } int TIFFInitCCITTFax3(TIFF* tif, int scheme) { if (InitCCITTFax3(tif)) { _TIFFMergeFieldInfo(tif, fax3FieldInfo, N(fax3FieldInfo)); /* * The default format is Class/F-style w/o RTC. */ return TIFFSetField(tif, TIFFTAG_FAXMODE, FAXMODE_CLASSF); } else return (0); } /* * CCITT Group 4 (T.6) Facsimile-compatible * Compression Scheme Support. */ #define SWAP(t,a,b) { t x; x = (a); (a) = (b); (b) = x; } /* * Decode the requested amount of G4-encoded data. */ static int Fax4Decode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s) { DECLARE_STATE_2D(tif, sp, "Fax4Decode"); (void) s; CACHE_STATE(tif, sp); while ((long)occ > 0) { a0 = 0; RunLength = 0; pa = thisrun = sp->curruns; pb = sp->refruns; b1 = *pb++; #ifdef FAX3_DEBUG printf("\nBitAcc=%08X, BitsAvail = %d\n", BitAcc, BitsAvail); printf("-------------------- %d\n", tif->tif_row); fflush(stdout); #endif EXPAND2D(EOFG4); (*sp->fill)(buf, thisrun, pa, lastx); SETVAL(0); /* imaginary change for reference */ SWAP(uint32*, sp->curruns, sp->refruns); buf += sp->b.rowbytes; occ -= sp->b.rowbytes; if (occ != 0) tif->tif_row++; continue; EOFG4: (*sp->fill)(buf, thisrun, pa, lastx); UNCACHE_STATE(tif, sp); return (-1); } UNCACHE_STATE(tif, sp); return (1); } #undef SWAP /* * Encode the requested amount of data. */ static int Fax4Encode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) { Fax3EncodeState *sp = EncoderState(tif); (void) s; while ((long)cc > 0) { if (!Fax3Encode2DRow(tif, bp, sp->refline, sp->b.rowpixels)) return (0); _TIFFmemcpy(sp->refline, bp, sp->b.rowbytes); bp += sp->b.rowbytes; cc -= sp->b.rowbytes; if (cc != 0) tif->tif_row++; } return (1); } static int Fax4PostEncode(TIFF* tif) { Fax3EncodeState *sp = EncoderState(tif); /* terminate strip w/ EOFB */ Fax3PutBits(tif, EOL, 12); Fax3PutBits(tif, EOL, 12); if (sp->bit != 8) Fax3FlushBits(tif, sp); return (1); } int TIFFInitCCITTFax4(TIFF* tif, int scheme) { if (InitCCITTFax3(tif)) { /* reuse G3 support */ _TIFFMergeFieldInfo(tif, fax4FieldInfo, N(fax4FieldInfo)); tif->tif_decoderow = Fax4Decode; tif->tif_decodestrip = Fax4Decode; tif->tif_decodetile = Fax4Decode; tif->tif_encoderow = Fax4Encode; tif->tif_encodestrip = Fax4Encode; tif->tif_encodetile = Fax4Encode; tif->tif_postencode = Fax4PostEncode; /* * Suppress RTC at the end of each strip. */ return TIFFSetField(tif, TIFFTAG_FAXMODE, FAXMODE_NORTC); } else return (0); } /* * CCITT Group 3 1-D Modified Huffman RLE Compression Support. * (Compression algorithms 2 and 32771) */ /* * Decode the requested amount of RLE-encoded data. */ static int Fax3DecodeRLE(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s) { DECLARE_STATE(tif, sp, "Fax3DecodeRLE"); int mode = sp->b.mode; (void) s; CACHE_STATE(tif, sp); thisrun = sp->curruns; while ((long)occ > 0) { a0 = 0; RunLength = 0; pa = thisrun; #ifdef FAX3_DEBUG printf("\nBitAcc=%08X, BitsAvail = %d\n", BitAcc, BitsAvail); printf("-------------------- %d\n", tif->tif_row); fflush(stdout); #endif EXPAND1D(EOFRLE); (*sp->fill)(buf, thisrun, pa, lastx); /* * Cleanup at the end of the row. */ if (mode & FAXMODE_BYTEALIGN) { int n = BitsAvail - (BitsAvail &~ 7); ClrBits(n); } else if (mode & FAXMODE_WORDALIGN) { int n = BitsAvail - (BitsAvail &~ 15); ClrBits(n); if (BitsAvail == 0 && !isAligned(cp, uint16)) cp++; } buf += sp->b.rowbytes; occ -= sp->b.rowbytes; if (occ != 0) tif->tif_row++; continue; EOFRLE: /* premature EOF */ (*sp->fill)(buf, thisrun, pa, lastx); UNCACHE_STATE(tif, sp); return (-1); } UNCACHE_STATE(tif, sp); return (1); } int TIFFInitCCITTRLE(TIFF* tif, int scheme) { if (InitCCITTFax3(tif)) { /* reuse G3 support */ tif->tif_decoderow = Fax3DecodeRLE; tif->tif_decodestrip = Fax3DecodeRLE; tif->tif_decodetile = Fax3DecodeRLE; /* * Suppress RTC+EOLs when encoding and byte-align data. */ return TIFFSetField(tif, TIFFTAG_FAXMODE, FAXMODE_NORTC|FAXMODE_NOEOL|FAXMODE_BYTEALIGN); } else return (0); } int TIFFInitCCITTRLEW(TIFF* tif, int scheme) { if (InitCCITTFax3(tif)) { /* reuse G3 support */ tif->tif_decoderow = Fax3DecodeRLE; tif->tif_decodestrip = Fax3DecodeRLE; tif->tif_decodetile = Fax3DecodeRLE; /* * Suppress RTC+EOLs when encoding and word-align data. */ return TIFFSetField(tif, TIFFTAG_FAXMODE, FAXMODE_NORTC|FAXMODE_NOEOL|FAXMODE_WORDALIGN); } else return (0); } #endif /* CCITT_SUPPORT */ netpbm-8.2/libtiff/tif_fax3.h0100660000076400000000000003635706770337333015212 0ustar bryanhroot/* $Id: tif_fax3.h,v 1.2 1999/09/17 04:08:59 mwelles Exp $ */ /* * Copyright (c) 1990-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. */ #ifndef _FAX3_ #define _FAX3_ /* * TIFF Library. * * CCITT Group 3 (T.4) and Group 4 (T.6) Decompression Support. * * Decoder support is derived, with permission, from the code * in Frank Cringle's viewfax program; * Copyright (C) 1990, 1995 Frank D. Cringle. */ #include "tiff.h" /* * To override the default routine used to image decoded * spans one can use the pseduo tag TIFFTAG_FAXFILLFUNC. * The routine must have the type signature given below; * for example: * * fillruns(unsigned char* buf, uint32* runs, uint32* erun, uint32 lastx) * * where buf is place to set the bits, runs is the array of b&w run * lengths (white then black), erun is the last run in the array, and * lastx is the width of the row in pixels. Fill routines can assume * the run array has room for at least lastx runs and can overwrite * data in the run array as needed (e.g. to append zero runs to bring * the count up to a nice multiple). */ typedef void (*TIFFFaxFillFunc)(unsigned char*, uint32*, uint32*, uint32); /* * The default run filler; made external for other decoders. */ #if defined(__cplusplus) extern "C" { #endif extern void _TIFFFax3fillruns(unsigned char*, uint32*, uint32*, uint32); #if defined(__cplusplus) } #endif /* finite state machine codes */ #define S_Null 0 #define S_Pass 1 #define S_Horiz 2 #define S_V0 3 #define S_VR 4 #define S_VL 5 #define S_Ext 6 #define S_TermW 7 #define S_TermB 8 #define S_MakeUpW 9 #define S_MakeUpB 10 #define S_MakeUp 11 #define S_EOL 12 typedef struct { /* state table entry */ unsigned char State; /* see above */ unsigned char Width; /* width of code in bits */ uint32 Param; /* unsigned 32-bit run length in bits */ } TIFFFaxTabEnt; extern const TIFFFaxTabEnt TIFFFaxMainTable[]; extern const TIFFFaxTabEnt TIFFFaxWhiteTable[]; extern const TIFFFaxTabEnt TIFFFaxBlackTable[]; /* * The following macros define the majority of the G3/G4 decoder * algorithm using the state tables defined elsewhere. To build * a decoder you need some setup code and some glue code. Note * that you may also need/want to change the way the NeedBits* * macros get input data if, for example, you know the data to be * decoded is properly aligned and oriented (doing so before running * the decoder can be a big performance win). * * Consult the decoder in the TIFF library for an idea of what you * need to define and setup to make use of these definitions. * * NB: to enable a debugging version of these macros define FAX3_DEBUG * before including this file. Trace output goes to stdout. */ #ifndef EndOfData #define EndOfData() (cp >= ep) #endif /* * Need <=8 or <=16 bits of input data. Unlike viewfax we * cannot use/assume a word-aligned, properly bit swizzled * input data set because data may come from an arbitrarily * aligned, read-only source such as a memory-mapped file. * Note also that the viewfax decoder does not check for * running off the end of the input data buffer. This is * possible for G3-encoded data because it prescans the input * data to count EOL markers, but can cause problems for G4 * data. In any event, we don't prescan and must watch for * running out of data since we can't permit the library to * scan past the end of the input data buffer. * * Finally, note that we must handle remaindered data at the end * of a strip specially. The coder asks for a fixed number of * bits when scanning for the next code. This may be more bits * than are actually present in the data stream. If we appear * to run out of data but still have some number of valid bits * remaining then we makeup the requested amount with zeros and * return successfully. If the returned data is incorrect then * we should be called again and get a premature EOF error; * otherwise we should get the right answer. */ #ifndef NeedBits8 #define NeedBits8(n,eoflab) do { \ if (BitsAvail < (n)) { \ if (EndOfData()) { \ if (BitsAvail == 0) /* no valid bits */ \ goto eoflab; \ BitsAvail = (n); /* pad with zeros */ \ } else { \ BitAcc |= ((uint32) bitmap[*cp++])<>= (n); \ } while (0) #ifdef FAX3_DEBUG static const char* StateNames[] = { "Null ", "Pass ", "Horiz ", "V0 ", "VR ", "VL ", "Ext ", "TermW ", "TermB ", "MakeUpW", "MakeUpB", "MakeUp ", "EOL ", }; #define DEBUG_SHOW putchar(BitAcc & (1 << t) ? '1' : '0') #define LOOKUP8(wid,tab,eoflab) do { \ int t; \ NeedBits8(wid,eoflab); \ TabEnt = tab + GetBits(wid); \ printf("%08lX/%d: %s%5d\t", (long) BitAcc, BitsAvail, \ StateNames[TabEnt->State], TabEnt->Param); \ for (t = 0; t < TabEnt->Width; t++) \ DEBUG_SHOW; \ putchar('\n'); \ fflush(stdout); \ ClrBits(TabEnt->Width); \ } while (0) #define LOOKUP16(wid,tab,eoflab) do { \ int t; \ NeedBits16(wid,eoflab); \ TabEnt = tab + GetBits(wid); \ printf("%08lX/%d: %s%5d\t", (long) BitAcc, BitsAvail, \ StateNames[TabEnt->State], TabEnt->Param); \ for (t = 0; t < TabEnt->Width; t++) \ DEBUG_SHOW; \ putchar('\n'); \ fflush(stdout); \ ClrBits(TabEnt->Width); \ } while (0) #define SETVAL(x) do { \ *pa++ = RunLength + (x); \ printf("SETVAL: %d\t%d\n", RunLength + (x), a0); \ a0 += x; \ RunLength = 0; \ } while (0) #else #define LOOKUP8(wid,tab,eoflab) do { \ NeedBits8(wid,eoflab); \ TabEnt = tab + GetBits(wid); \ ClrBits(TabEnt->Width); \ } while (0) #define LOOKUP16(wid,tab,eoflab) do { \ NeedBits16(wid,eoflab); \ TabEnt = tab + GetBits(wid); \ ClrBits(TabEnt->Width); \ } while (0) /* * Append a run to the run length array for the * current row and reset decoding state. */ #define SETVAL(x) do { \ *pa++ = RunLength + (x); \ a0 += (x); \ RunLength = 0; \ } while (0) #endif /* * Synchronize input decoding at the start of each * row by scanning for an EOL (if appropriate) and * skipping any trash data that might be present * after a decoding error. Note that the decoding * done elsewhere that recognizes an EOL only consumes * 11 consecutive zero bits. This means that if EOLcnt * is non-zero then we still need to scan for the final flag * bit that is part of the EOL code. */ #define SYNC_EOL(eoflab) do { \ if (EOLcnt == 0) { \ for (;;) { \ NeedBits16(11,eoflab); \ if (GetBits(11) == 0) \ break; \ ClrBits(1); \ } \ } \ for (;;) { \ NeedBits8(8,eoflab); \ if (GetBits(8)) \ break; \ ClrBits(8); \ } \ while (GetBits(1) == 0) \ ClrBits(1); \ ClrBits(1); /* EOL bit */ \ EOLcnt = 0; /* reset EOL counter/flag */ \ } while (0) /* * Cleanup the array of runs after decoding a row. * We adjust final runs to insure the user buffer is not * overwritten and/or undecoded area is white filled. */ #define CLEANUP_RUNS() do { \ if (RunLength) \ SETVAL(0); \ if (a0 != lastx) { \ badlength(a0, lastx); \ while (a0 > lastx && pa > thisrun) \ a0 -= *--pa; \ if (a0 < lastx) { \ if (a0 < 0) \ a0 = 0; \ if ((pa-thisrun)&1) \ SETVAL(0); \ SETVAL(lastx - a0); \ } else if (a0 > lastx) { \ SETVAL(lastx); \ SETVAL(0); \ } \ } \ } while (0) /* * Decode a line of 1D-encoded data. * * The line expanders are written as macros so that they can be reused * but still have direct access to the local variables of the "calling" * function. * * Note that unlike the original version we have to explicitly test for * a0 >= lastx after each black/white run is decoded. This is because * the original code depended on the input data being zero-padded to * insure the decoder recognized an EOL before running out of data. */ #define EXPAND1D(eoflab) do { \ for (;;) { \ for (;;) { \ LOOKUP16(12, TIFFFaxWhiteTable, eof1d); \ switch (TabEnt->State) { \ case S_EOL: \ EOLcnt = 1; \ goto done1d; \ case S_TermW: \ SETVAL(TabEnt->Param); \ goto doneWhite1d; \ case S_MakeUpW: \ case S_MakeUp: \ a0 += TabEnt->Param; \ RunLength += TabEnt->Param; \ break; \ default: \ unexpected("WhiteTable", a0); \ goto done1d; \ } \ } \ doneWhite1d: \ if (a0 >= lastx) \ goto done1d; \ for (;;) { \ LOOKUP16(13, TIFFFaxBlackTable, eof1d); \ switch (TabEnt->State) { \ case S_EOL: \ EOLcnt = 1; \ goto done1d; \ case S_TermB: \ SETVAL(TabEnt->Param); \ goto doneBlack1d; \ case S_MakeUpB: \ case S_MakeUp: \ a0 += TabEnt->Param; \ RunLength += TabEnt->Param; \ break; \ default: \ unexpected("BlackTable", a0); \ goto done1d; \ } \ } \ doneBlack1d: \ if (a0 >= lastx) \ goto done1d; \ } \ eof1d: \ prematureEOF(a0); \ CLEANUP_RUNS(); \ goto eoflab; \ done1d: \ CLEANUP_RUNS(); \ } while (0) /* * Update the value of b1 using the array * of runs for the reference line. */ #define CHECK_b1 do { \ if (pa != thisrun) while (b1 <= a0 && b1 < lastx) { \ b1 += pb[0] + pb[1]; \ pb += 2; \ } \ } while (0) /* * Expand a row of 2D-encoded data. */ #define EXPAND2D(eoflab) do { \ while (a0 < lastx) { \ LOOKUP8(7, TIFFFaxMainTable, eof2d); \ switch (TabEnt->State) { \ case S_Pass: \ CHECK_b1; \ b1 += *pb++; \ RunLength += b1 - a0; \ a0 = b1; \ b1 += *pb++; \ break; \ case S_Horiz: \ if ((pa-thisrun)&1) { \ for (;;) { /* black first */ \ LOOKUP16(13, TIFFFaxBlackTable, eof2d); \ switch (TabEnt->State) { \ case S_TermB: \ SETVAL(TabEnt->Param); \ goto doneWhite2da; \ case S_MakeUpB: \ case S_MakeUp: \ a0 += TabEnt->Param; \ RunLength += TabEnt->Param; \ break; \ default: \ goto badBlack2d; \ } \ } \ doneWhite2da:; \ for (;;) { /* then white */ \ LOOKUP16(12, TIFFFaxWhiteTable, eof2d); \ switch (TabEnt->State) { \ case S_TermW: \ SETVAL(TabEnt->Param); \ goto doneBlack2da; \ case S_MakeUpW: \ case S_MakeUp: \ a0 += TabEnt->Param; \ RunLength += TabEnt->Param; \ break; \ default: \ goto badWhite2d; \ } \ } \ doneBlack2da:; \ } else { \ for (;;) { /* white first */ \ LOOKUP16(12, TIFFFaxWhiteTable, eof2d); \ switch (TabEnt->State) { \ case S_TermW: \ SETVAL(TabEnt->Param); \ goto doneWhite2db; \ case S_MakeUpW: \ case S_MakeUp: \ a0 += TabEnt->Param; \ RunLength += TabEnt->Param; \ break; \ default: \ goto badWhite2d; \ } \ } \ doneWhite2db:; \ for (;;) { /* then black */ \ LOOKUP16(13, TIFFFaxBlackTable, eof2d); \ switch (TabEnt->State) { \ case S_TermB: \ SETVAL(TabEnt->Param); \ goto doneBlack2db; \ case S_MakeUpB: \ case S_MakeUp: \ a0 += TabEnt->Param; \ RunLength += TabEnt->Param; \ break; \ default: \ goto badBlack2d; \ } \ } \ doneBlack2db:; \ } \ CHECK_b1; \ break; \ case S_V0: \ CHECK_b1; \ SETVAL(b1 - a0); \ b1 += *pb++; \ break; \ case S_VR: \ CHECK_b1; \ SETVAL(b1 - a0 + TabEnt->Param); \ b1 += *pb++; \ break; \ case S_VL: \ CHECK_b1; \ SETVAL(b1 - a0 - TabEnt->Param); \ b1 -= *--pb; \ break; \ case S_Ext: \ *pa++ = lastx - a0; \ extension(a0); \ goto eol2d; \ case S_EOL: \ *pa++ = lastx - a0; \ NeedBits8(5,eof2d); \ if (GetBits(5)) \ unexpected("EOL", a0); \ EOLcnt = 1; \ goto eol2d; \ default: \ badMain2d: \ unexpected("MainTable", a0); \ goto eol2d; \ badBlack2d: \ unexpected("BlackTable", a0); \ goto eol2d; \ badWhite2d: \ unexpected("WhiteTable", a0); \ goto eol2d; \ eof2d: \ prematureEOF(a0); \ CLEANUP_RUNS(); \ goto eoflab; \ } \ } \ if (RunLength) { \ if (RunLength + a0 < lastx) { \ /* expect a final V0 */ \ NeedBits8(1,eof2d); \ if (!GetBits(1)) \ goto badMain2d; \ ClrBits(1); \ } \ SETVAL(0); \ } \ eol2d: \ CLEANUP_RUNS(); \ } while (0) #endif /* _FAX3_ */ netpbm-8.2/libtiff/tif_flush.c0100660000076400000000000000352506747424643015461 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_flush.c,v 1.1.1.1 1999/07/27 21:50:27 mike Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library. */ #include "tiffiop.h" int TIFFFlush(TIFF* tif) { if (tif->tif_mode != O_RDONLY) { if (!TIFFFlushData(tif)) return (0); if ((tif->tif_flags & TIFF_DIRTYDIRECT) && !TIFFWriteDirectory(tif)) return (0); } return (1); } /* * Flush buffered data to the file. */ int TIFFFlushData(TIFF* tif) { if ((tif->tif_flags & TIFF_BEENWRITING) == 0) return (0); if (tif->tif_flags & TIFF_POSTENCODE) { tif->tif_flags &= ~TIFF_POSTENCODE; if (!(*tif->tif_postencode)(tif)) return (0); } return (TIFFFlushData1(tif)); } netpbm-8.2/libtiff/tif_getimage.c0100660000076400000000000014650307020046732016106 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_getimage.c,v 1.4 1999/11/27 21:32:10 warmerda Exp $ */ /* * Copyright (c) 1991-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library * * Read and return a packed RGBA image. */ #include "tiffiop.h" #include #include static int gtTileContig(TIFFRGBAImage*, uint32*, uint32, uint32); static int gtTileSeparate(TIFFRGBAImage*, uint32*, uint32, uint32); static int gtStripContig(TIFFRGBAImage*, uint32*, uint32, uint32); static int gtStripSeparate(TIFFRGBAImage*, uint32*, uint32, uint32); static int pickTileContigCase(TIFFRGBAImage*); static int pickTileSeparateCase(TIFFRGBAImage*); static const char photoTag[] = "PhotometricInterpretation"; /* * Check the image to see if TIFFReadRGBAImage can deal with it. * 1/0 is returned according to whether or not the image can * be handled. If 0 is returned, emsg contains the reason * why it is being rejected. */ int TIFFRGBAImageOK(TIFF* tif, char emsg[1024]) { TIFFDirectory* td = &tif->tif_dir; uint16 photometric; int colorchannels; switch (td->td_bitspersample) { case 1: case 2: case 4: case 8: case 16: break; default: sprintf(emsg, "Sorry, can not handle images with %d-bit samples", td->td_bitspersample); return (0); } colorchannels = td->td_samplesperpixel - td->td_extrasamples; if (!TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &photometric)) { switch (colorchannels) { case 1: photometric = PHOTOMETRIC_MINISBLACK; break; case 3: photometric = PHOTOMETRIC_RGB; break; default: sprintf(emsg, "Missing needed %s tag", photoTag); return (0); } } switch (photometric) { case PHOTOMETRIC_MINISWHITE: case PHOTOMETRIC_MINISBLACK: case PHOTOMETRIC_PALETTE: if (td->td_planarconfig == PLANARCONFIG_CONTIG && td->td_samplesperpixel != 1) { sprintf(emsg, "Sorry, can not handle contiguous data with %s=%d, and %s=%d", photoTag, photometric, "Samples/pixel", td->td_samplesperpixel); return (0); } break; case PHOTOMETRIC_YCBCR: if (td->td_planarconfig != PLANARCONFIG_CONTIG) { sprintf(emsg, "Sorry, can not handle YCbCr images with %s=%d", "Planarconfiguration", td->td_planarconfig); return (0); } break; case PHOTOMETRIC_RGB: if (colorchannels < 3) { sprintf(emsg, "Sorry, can not handle RGB image with %s=%d", "Color channels", colorchannels); return (0); } break; #ifdef CMYK_SUPPORT case PHOTOMETRIC_SEPARATED: if (td->td_inkset != INKSET_CMYK) { sprintf(emsg, "Sorry, can not handle separated image with %s=%d", "InkSet", td->td_inkset); return (0); } if (td->td_samplesperpixel != 4) { sprintf(emsg, "Sorry, can not handle separated image with %s=%d", "Samples/pixel", td->td_samplesperpixel); return (0); } break; #endif case PHOTOMETRIC_LOGL: if (td->td_compression != COMPRESSION_SGILOG) { sprintf(emsg, "Sorry, LogL data must have %s=%d", "Compression", COMPRESSION_SGILOG); return (0); } break; case PHOTOMETRIC_LOGLUV: if (td->td_compression != COMPRESSION_SGILOG && td->td_compression != COMPRESSION_SGILOG24) { sprintf(emsg, "Sorry, LogLuv data must have %s=%d or %d", "Compression", COMPRESSION_SGILOG, COMPRESSION_SGILOG24); return (0); } if (td->td_planarconfig != PLANARCONFIG_CONTIG) { sprintf(emsg, "Sorry, can not handle LogLuv images with %s=%d", "Planarconfiguration", td->td_planarconfig); return (0); } break; default: sprintf(emsg, "Sorry, can not handle image with %s=%d", photoTag, photometric); return (0); } return (1); } void TIFFRGBAImageEnd(TIFFRGBAImage* img) { if (img->Map) _TIFFfree(img->Map), img->Map = NULL; if (img->BWmap) _TIFFfree(img->BWmap), img->BWmap = NULL; if (img->PALmap) _TIFFfree(img->PALmap), img->PALmap = NULL; if (img->ycbcr) _TIFFfree(img->ycbcr), img->ycbcr = NULL; if( img->redcmap ) { _TIFFfree( img->redcmap ); _TIFFfree( img->greencmap ); _TIFFfree( img->bluecmap ); } } static int isCCITTCompression(TIFF* tif) { uint16 compress; TIFFGetField(tif, TIFFTAG_COMPRESSION, &compress); return (compress == COMPRESSION_CCITTFAX3 || compress == COMPRESSION_CCITTFAX4 || compress == COMPRESSION_CCITTRLE || compress == COMPRESSION_CCITTRLEW); } int TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024]) { uint16* sampleinfo; uint16 extrasamples; uint16 planarconfig; uint16 compress; int colorchannels; uint16 *red_orig, *green_orig, *blue_orig; int n_color; /* Initialize to normal values */ img->row_offset = 0; img->col_offset = 0; img->redcmap = NULL; img->greencmap = NULL; img->bluecmap = NULL; img->tif = tif; img->stoponerr = stop; TIFFGetFieldDefaulted(tif, TIFFTAG_BITSPERSAMPLE, &img->bitspersample); switch (img->bitspersample) { case 1: case 2: case 4: case 8: case 16: break; default: sprintf(emsg, "Sorry, can not image with %d-bit samples", img->bitspersample); return (0); } img->alpha = 0; TIFFGetFieldDefaulted(tif, TIFFTAG_SAMPLESPERPIXEL, &img->samplesperpixel); TIFFGetFieldDefaulted(tif, TIFFTAG_EXTRASAMPLES, &extrasamples, &sampleinfo); if (extrasamples == 1) switch (sampleinfo[0]) { case EXTRASAMPLE_ASSOCALPHA: /* data is pre-multiplied */ case EXTRASAMPLE_UNASSALPHA: /* data is not pre-multiplied */ img->alpha = sampleinfo[0]; break; } colorchannels = img->samplesperpixel - extrasamples; TIFFGetFieldDefaulted(tif, TIFFTAG_COMPRESSION, &compress); TIFFGetFieldDefaulted(tif, TIFFTAG_PLANARCONFIG, &planarconfig); if (!TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &img->photometric)) { switch (colorchannels) { case 1: if (isCCITTCompression(tif)) img->photometric = PHOTOMETRIC_MINISWHITE; else img->photometric = PHOTOMETRIC_MINISBLACK; break; case 3: img->photometric = PHOTOMETRIC_RGB; break; default: sprintf(emsg, "Missing needed %s tag", photoTag); return (0); } } switch (img->photometric) { case PHOTOMETRIC_PALETTE: if (!TIFFGetField(tif, TIFFTAG_COLORMAP, &red_orig, &green_orig, &blue_orig)) { TIFFError(TIFFFileName(tif), "Missing required \"Colormap\" tag"); return (0); } /* copy the colormaps so we can modify them */ n_color = (1L << img->bitspersample); img->redcmap = (uint16 *) _TIFFmalloc(sizeof(uint16)*n_color); img->greencmap = (uint16 *) _TIFFmalloc(sizeof(uint16)*n_color); img->bluecmap = (uint16 *) _TIFFmalloc(sizeof(uint16)*n_color); if( !img->redcmap || !img->greencmap || !img->bluecmap ) { TIFFError(TIFFFileName(tif), "Out of memory for colormap copy"); return (0); } memcpy( img->redcmap, red_orig, n_color * 2 ); memcpy( img->greencmap, green_orig, n_color * 2 ); memcpy( img->bluecmap, blue_orig, n_color * 2 ); /* fall thru... */ case PHOTOMETRIC_MINISWHITE: case PHOTOMETRIC_MINISBLACK: if (planarconfig == PLANARCONFIG_CONTIG && img->samplesperpixel != 1) { sprintf(emsg, "Sorry, can not handle contiguous data with %s=%d, and %s=%d", photoTag, img->photometric, "Samples/pixel", img->samplesperpixel); return (0); } break; case PHOTOMETRIC_YCBCR: if (planarconfig != PLANARCONFIG_CONTIG) { sprintf(emsg, "Sorry, can not handle YCbCr images with %s=%d", "Planarconfiguration", planarconfig); return (0); } /* It would probably be nice to have a reality check here. */ if (compress == COMPRESSION_JPEG && planarconfig == PLANARCONFIG_CONTIG) { /* can rely on libjpeg to convert to RGB */ /* XXX should restore current state on exit */ TIFFSetField(tif, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB); img->photometric = PHOTOMETRIC_RGB; } break; case PHOTOMETRIC_RGB: if (colorchannels < 3) { sprintf(emsg, "Sorry, can not handle RGB image with %s=%d", "Color channels", colorchannels); return (0); } break; case PHOTOMETRIC_SEPARATED: { uint16 inkset; TIFFGetFieldDefaulted(tif, TIFFTAG_INKSET, &inkset); if (inkset != INKSET_CMYK) { sprintf(emsg, "Sorry, can not handle separated image with %s=%d", "InkSet", inkset); return (0); } if (img->samplesperpixel != 4) { sprintf(emsg, "Sorry, can not handle separated image with %s=%d", "Samples/pixel", img->samplesperpixel); return (0); } break; } case PHOTOMETRIC_LOGL: if (compress != COMPRESSION_SGILOG) { sprintf(emsg, "Sorry, LogL data must have %s=%d", "Compression", COMPRESSION_SGILOG); return (0); } TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_8BIT); img->photometric = PHOTOMETRIC_MINISBLACK; /* little white lie */ img->bitspersample = 8; break; case PHOTOMETRIC_LOGLUV: if (compress != COMPRESSION_SGILOG && compress != COMPRESSION_SGILOG24) { sprintf(emsg, "Sorry, LogLuv data must have %s=%d or %d", "Compression", COMPRESSION_SGILOG, COMPRESSION_SGILOG24); return (0); } if (planarconfig != PLANARCONFIG_CONTIG) { sprintf(emsg, "Sorry, can not handle LogLuv images with %s=%d", "Planarconfiguration", planarconfig); return (0); } TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_8BIT); img->photometric = PHOTOMETRIC_RGB; /* little white lie */ img->bitspersample = 8; break; default: sprintf(emsg, "Sorry, can not handle image with %s=%d", photoTag, img->photometric); return (0); } img->Map = NULL; img->BWmap = NULL; img->PALmap = NULL; img->ycbcr = NULL; TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &img->width); TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &img->height); TIFFGetFieldDefaulted(tif, TIFFTAG_ORIENTATION, &img->orientation); img->isContig = !(planarconfig == PLANARCONFIG_SEPARATE && colorchannels > 1); if (img->isContig) { img->get = TIFFIsTiled(tif) ? gtTileContig : gtStripContig; (void) pickTileContigCase(img); } else { img->get = TIFFIsTiled(tif) ? gtTileSeparate : gtStripSeparate; (void) pickTileSeparateCase(img); } return (1); } int TIFFRGBAImageGet(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h) { if (img->get == NULL) { TIFFError(TIFFFileName(img->tif), "No \"get\" routine setup"); return (0); } if (img->put.any == NULL) { TIFFError(TIFFFileName(img->tif), "No \"put\" routine setupl; probably can not handle image format"); return (0); } return (*img->get)(img, raster, w, h); } /* * Read the specified image into an ABGR-format raster. */ int TIFFReadRGBAImage(TIFF* tif, uint32 rwidth, uint32 rheight, uint32* raster, int stop) { char emsg[1024]; TIFFRGBAImage img; int ok; if (TIFFRGBAImageBegin(&img, tif, stop, emsg)) { /* XXX verify rwidth and rheight against width and height */ ok = TIFFRGBAImageGet(&img, raster+(rheight-img.height)*rwidth, rwidth, img.height); TIFFRGBAImageEnd(&img); } else { TIFFError(TIFFFileName(tif), emsg); ok = 0; } return (ok); } static uint32 setorientation(TIFFRGBAImage* img, uint32 h) { TIFF* tif = img->tif; uint32 y; switch (img->orientation) { case ORIENTATION_BOTRIGHT: case ORIENTATION_RIGHTBOT: /* XXX */ case ORIENTATION_LEFTBOT: /* XXX */ TIFFWarning(TIFFFileName(tif), "using bottom-left orientation"); img->orientation = ORIENTATION_BOTLEFT; /* fall thru... */ case ORIENTATION_BOTLEFT: y = 0; break; case ORIENTATION_TOPRIGHT: case ORIENTATION_RIGHTTOP: /* XXX */ case ORIENTATION_LEFTTOP: /* XXX */ default: TIFFWarning(TIFFFileName(tif), "using top-left orientation"); img->orientation = ORIENTATION_TOPLEFT; /* fall thru... */ case ORIENTATION_TOPLEFT: y = h-1; break; } return (y); } /* * Get an tile-organized image that has * PlanarConfiguration contiguous if SamplesPerPixel > 1 * or * SamplesPerPixel == 1 */ static int gtTileContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h) { TIFF* tif = img->tif; tileContigRoutine put = img->put.contig; uint16 orientation; uint32 col, row, y; uint32 tw, th; u_char* buf; int32 fromskew, toskew; uint32 nrow; buf = (u_char*) _TIFFmalloc(TIFFTileSize(tif)); if (buf == 0) { TIFFError(TIFFFileName(tif), "No space for tile buffer"); return (0); } TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tw); TIFFGetField(tif, TIFFTAG_TILELENGTH, &th); y = setorientation(img, h); orientation = img->orientation; toskew = -(int32) (orientation == ORIENTATION_TOPLEFT ? tw+w : tw-w); for (row = 0; row < h; row += th) { nrow = (row + th > h ? h - row : th); for (col = 0; col < w; col += tw) { if (TIFFReadTile(tif, buf, col+img->col_offset, row+img->row_offset, 0, 0) < 0 && img->stoponerr) break; if (col + tw > w) { /* * Tile is clipped horizontally. Calculate * visible portion and skewing factors. */ uint32 npix = w - col; fromskew = tw - npix; (*put)(img, raster+y*w+col, col, y, npix, nrow, fromskew, toskew + fromskew, buf); } else { (*put)(img, raster+y*w+col, col, y, tw, nrow, 0, toskew, buf); } } y += (orientation == ORIENTATION_TOPLEFT ? -(int32) nrow : (int32) nrow); } _TIFFfree(buf); return (1); } /* * Get an tile-organized image that has * SamplesPerPixel > 1 * PlanarConfiguration separated * We assume that all such images are RGB. */ static int gtTileSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h) { TIFF* tif = img->tif; tileSeparateRoutine put = img->put.separate; uint16 orientation; uint32 col, row, y; uint32 tw, th; u_char* buf; u_char* r; u_char* g; u_char* b; u_char* a; tsize_t tilesize; int32 fromskew, toskew; int alpha = img->alpha; uint32 nrow; tilesize = TIFFTileSize(tif); buf = (u_char*) _TIFFmalloc(4*tilesize); if (buf == 0) { TIFFError(TIFFFileName(tif), "No space for tile buffer"); return (0); } r = buf; g = r + tilesize; b = g + tilesize; a = b + tilesize; if (!alpha) memset(a, 0xff, tilesize); TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tw); TIFFGetField(tif, TIFFTAG_TILELENGTH, &th); y = setorientation(img, h); orientation = img->orientation; toskew = -(int32) (orientation == ORIENTATION_TOPLEFT ? tw+w : tw-w); for (row = 0; row < h; row += th) { nrow = (row + th > h ? h - row : th); for (col = 0; col < w; col += tw) { if (TIFFReadTile(tif, r, col+img->col_offset, row+img->row_offset,0,0) < 0 && img->stoponerr) break; if (TIFFReadTile(tif, g, col+img->col_offset, row+img->row_offset,0,1) < 0 && img->stoponerr) break; if (TIFFReadTile(tif, b, col+img->col_offset, row+img->row_offset,0,2) < 0 && img->stoponerr) break; if (alpha && TIFFReadTile(tif,a,col+img->col_offset, row+img->row_offset,0,3) < 0 && img->stoponerr) break; if (col + tw > w) { /* * Tile is clipped horizontally. Calculate * visible portion and skewing factors. */ uint32 npix = w - col; fromskew = tw - npix; (*put)(img, raster+y*w+col, col, y, npix, nrow, fromskew, toskew + fromskew, r, g, b, a); } else { (*put)(img, raster+y*w+col, col, y, tw, nrow, 0, toskew, r, g, b, a); } } y += (orientation == ORIENTATION_TOPLEFT ? -(int32) nrow : (int32) nrow); } _TIFFfree(buf); return (1); } /* * Get a strip-organized image that has * PlanarConfiguration contiguous if SamplesPerPixel > 1 * or * SamplesPerPixel == 1 */ static int gtStripContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h) { TIFF* tif = img->tif; tileContigRoutine put = img->put.contig; uint16 orientation; uint32 row, y, nrow; u_char* buf; uint32 rowsperstrip; uint32 imagewidth = img->width; tsize_t scanline; int32 fromskew, toskew; buf = (u_char*) _TIFFmalloc(TIFFStripSize(tif)); if (buf == 0) { TIFFError(TIFFFileName(tif), "No space for strip buffer"); return (0); } y = setorientation(img, h); orientation = img->orientation; toskew = -(int32) (orientation == ORIENTATION_TOPLEFT ? w+w : w-w); TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip); scanline = TIFFScanlineSize(tif); fromskew = (w < imagewidth ? imagewidth - w : 0); for (row = 0; row < h; row += rowsperstrip) { nrow = (row + rowsperstrip > h ? h - row : rowsperstrip); if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif,row+img->row_offset, 0), buf, nrow*scanline) < 0 && img->stoponerr) break; (*put)(img, raster+y*w, 0, y, w, nrow, fromskew, toskew, buf); y += (orientation == ORIENTATION_TOPLEFT ? -(int32) nrow : (int32) nrow); } _TIFFfree(buf); return (1); } /* * Get a strip-organized image with * SamplesPerPixel > 1 * PlanarConfiguration separated * We assume that all such images are RGB. */ static int gtStripSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h) { TIFF* tif = img->tif; tileSeparateRoutine put = img->put.separate; uint16 orientation; u_char *buf; u_char *r, *g, *b, *a; uint32 row, y, nrow; tsize_t scanline; uint32 rowsperstrip, offset_row; uint32 imagewidth = img->width; tsize_t stripsize; int32 fromskew, toskew; int alpha = img->alpha; stripsize = TIFFStripSize(tif); r = buf = (u_char *)_TIFFmalloc(4*stripsize); if (buf == 0) { TIFFError(TIFFFileName(tif), "No space for tile buffer"); return (0); } g = r + stripsize; b = g + stripsize; a = b + stripsize; if (!alpha) memset(a, 0xff, stripsize); y = setorientation(img, h); orientation = img->orientation; toskew = -(int32) (orientation == ORIENTATION_TOPLEFT ? w+w : w-w); TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip); scanline = TIFFScanlineSize(tif); fromskew = (w < imagewidth ? imagewidth - w : 0); for (row = 0; row < h; row += rowsperstrip) { nrow = (row + rowsperstrip > h ? h - row : rowsperstrip); offset_row = row + img->row_offset; if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 0), r, nrow*scanline) < 0 && img->stoponerr) break; if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 1), g, nrow*scanline) < 0 && img->stoponerr) break; if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 2), b, nrow*scanline) < 0 && img->stoponerr) break; if (alpha && (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 3), a, nrow*scanline) < 0 && img->stoponerr)) break; (*put)(img, raster+y*w, 0, y, w, nrow, fromskew, toskew, r, g, b, a); y += (orientation == ORIENTATION_TOPLEFT ? -(int32) nrow : (int32) nrow); } _TIFFfree(buf); return (1); } /* * The following routines move decoded data returned * from the TIFF library into rasters filled with packed * ABGR pixels (i.e. suitable for passing to lrecwrite.) * * The routines have been created according to the most * important cases and optimized. pickTileContigCase and * pickTileSeparateCase analyze the parameters and select * the appropriate "put" routine to use. */ #define REPEAT8(op) REPEAT4(op); REPEAT4(op) #define REPEAT4(op) REPEAT2(op); REPEAT2(op) #define REPEAT2(op) op; op #define CASE8(x,op) \ switch (x) { \ case 7: op; case 6: op; case 5: op; \ case 4: op; case 3: op; case 2: op; \ case 1: op; \ } #define CASE4(x,op) switch (x) { case 3: op; case 2: op; case 1: op; } #define NOP #define UNROLL8(w, op1, op2) { \ uint32 _x; \ for (_x = w; _x >= 8; _x -= 8) { \ op1; \ REPEAT8(op2); \ } \ if (_x > 0) { \ op1; \ CASE8(_x,op2); \ } \ } #define UNROLL4(w, op1, op2) { \ uint32 _x; \ for (_x = w; _x >= 4; _x -= 4) { \ op1; \ REPEAT4(op2); \ } \ if (_x > 0) { \ op1; \ CASE4(_x,op2); \ } \ } #define UNROLL2(w, op1, op2) { \ uint32 _x; \ for (_x = w; _x >= 2; _x -= 2) { \ op1; \ REPEAT2(op2); \ } \ if (_x) { \ op1; \ op2; \ } \ } #define SKEW(r,g,b,skew) { r += skew; g += skew; b += skew; } #define SKEW4(r,g,b,a,skew) { r += skew; g += skew; b += skew; a+= skew; } #define A1 ((uint32)(0xffL<<24)) #define PACK(r,g,b) \ ((uint32)(r)|((uint32)(g)<<8)|((uint32)(b)<<16)|A1) #define PACK4(r,g,b,a) \ ((uint32)(r)|((uint32)(g)<<8)|((uint32)(b)<<16)|((uint32)(a)<<24)) #define W2B(v) (((v)>>8)&0xff) #define PACKW(r,g,b) \ ((uint32)W2B(r)|((uint32)W2B(g)<<8)|((uint32)W2B(b)<<16)|A1) #define PACKW4(r,g,b,a) \ ((uint32)W2B(r)|((uint32)W2B(g)<<8)|((uint32)W2B(b)<<16)|((uint32)W2B(a)<<24)) #define DECLAREContigPutFunc(name) \ static void name(\ TIFFRGBAImage* img, \ uint32* cp, \ uint32 x, uint32 y, \ uint32 w, uint32 h, \ int32 fromskew, int32 toskew, \ u_char* pp \ ) /* * 8-bit palette => colormap/RGB */ DECLAREContigPutFunc(put8bitcmaptile) { uint32** PALmap = img->PALmap; (void) x; (void) y; while (h-- > 0) { UNROLL8(w, NOP, *cp++ = PALmap[*pp++][0]); cp += toskew; pp += fromskew; } } /* * 4-bit palette => colormap/RGB */ DECLAREContigPutFunc(put4bitcmaptile) { uint32** PALmap = img->PALmap; (void) x; (void) y; fromskew /= 2; while (h-- > 0) { uint32* bw; UNROLL2(w, bw = PALmap[*pp++], *cp++ = *bw++); cp += toskew; pp += fromskew; } } /* * 2-bit palette => colormap/RGB */ DECLAREContigPutFunc(put2bitcmaptile) { uint32** PALmap = img->PALmap; (void) x; (void) y; fromskew /= 4; while (h-- > 0) { uint32* bw; UNROLL4(w, bw = PALmap[*pp++], *cp++ = *bw++); cp += toskew; pp += fromskew; } } /* * 1-bit palette => colormap/RGB */ DECLAREContigPutFunc(put1bitcmaptile) { uint32** PALmap = img->PALmap; (void) x; (void) y; fromskew /= 8; while (h-- > 0) { uint32* bw; UNROLL8(w, bw = PALmap[*pp++], *cp++ = *bw++); cp += toskew; pp += fromskew; } } /* * 8-bit greyscale => colormap/RGB */ DECLAREContigPutFunc(putgreytile) { uint32** BWmap = img->BWmap; (void) y; while (h-- > 0) { for (x = w; x-- > 0;) *cp++ = BWmap[*pp++][0]; cp += toskew; pp += fromskew; } } /* * 1-bit bilevel => colormap/RGB */ DECLAREContigPutFunc(put1bitbwtile) { uint32** BWmap = img->BWmap; (void) x; (void) y; fromskew /= 8; while (h-- > 0) { uint32* bw; UNROLL8(w, bw = BWmap[*pp++], *cp++ = *bw++); cp += toskew; pp += fromskew; } } /* * 2-bit greyscale => colormap/RGB */ DECLAREContigPutFunc(put2bitbwtile) { uint32** BWmap = img->BWmap; (void) x; (void) y; fromskew /= 4; while (h-- > 0) { uint32* bw; UNROLL4(w, bw = BWmap[*pp++], *cp++ = *bw++); cp += toskew; pp += fromskew; } } /* * 4-bit greyscale => colormap/RGB */ DECLAREContigPutFunc(put4bitbwtile) { uint32** BWmap = img->BWmap; (void) x; (void) y; fromskew /= 2; while (h-- > 0) { uint32* bw; UNROLL2(w, bw = BWmap[*pp++], *cp++ = *bw++); cp += toskew; pp += fromskew; } } /* * 8-bit packed samples, no Map => RGB */ DECLAREContigPutFunc(putRGBcontig8bittile) { int samplesperpixel = img->samplesperpixel; (void) x; (void) y; fromskew *= samplesperpixel; while (h-- > 0) { UNROLL8(w, NOP, *cp++ = PACK(pp[0], pp[1], pp[2]); pp += samplesperpixel); cp += toskew; pp += fromskew; } } /* * 8-bit packed samples, w/ Map => RGB */ DECLAREContigPutFunc(putRGBcontig8bitMaptile) { TIFFRGBValue* Map = img->Map; int samplesperpixel = img->samplesperpixel; (void) y; fromskew *= samplesperpixel; while (h-- > 0) { for (x = w; x-- > 0;) { *cp++ = PACK(Map[pp[0]], Map[pp[1]], Map[pp[2]]); pp += samplesperpixel; } pp += fromskew; cp += toskew; } } /* * 8-bit packed samples => RGBA w/ associated alpha * (known to have Map == NULL) */ DECLAREContigPutFunc(putRGBAAcontig8bittile) { int samplesperpixel = img->samplesperpixel; (void) x; (void) y; fromskew *= samplesperpixel; while (h-- > 0) { UNROLL8(w, NOP, *cp++ = PACK4(pp[0], pp[1], pp[2], pp[3]); pp += samplesperpixel); cp += toskew; pp += fromskew; } } /* * 8-bit packed samples => RGBA w/ unassociated alpha * (known to have Map == NULL) */ DECLAREContigPutFunc(putRGBUAcontig8bittile) { int samplesperpixel = img->samplesperpixel; (void) y; fromskew *= samplesperpixel; while (h-- > 0) { uint32 r, g, b, a; for (x = w; x-- > 0;) { a = pp[3]; r = (pp[0] * a) / 255; g = (pp[1] * a) / 255; b = (pp[2] * a) / 255; *cp++ = PACK4(r,g,b,a); pp += samplesperpixel; } cp += toskew; pp += fromskew; } } /* * 16-bit packed samples => RGB */ DECLAREContigPutFunc(putRGBcontig16bittile) { int samplesperpixel = img->samplesperpixel; uint16 *wp = (uint16 *)pp; (void) y; fromskew *= samplesperpixel; while (h-- > 0) { for (x = w; x-- > 0;) { *cp++ = PACKW(wp[0], wp[1], wp[2]); wp += samplesperpixel; } cp += toskew; wp += fromskew; } } /* * 16-bit packed samples => RGBA w/ associated alpha * (known to have Map == NULL) */ DECLAREContigPutFunc(putRGBAAcontig16bittile) { int samplesperpixel = img->samplesperpixel; uint16 *wp = (uint16 *)pp; (void) y; fromskew *= samplesperpixel; while (h-- > 0) { for (x = w; x-- > 0;) { *cp++ = PACKW4(wp[0], wp[1], wp[2], wp[3]); wp += samplesperpixel; } cp += toskew; wp += fromskew; } } /* * 16-bit packed samples => RGBA w/ unassociated alpha * (known to have Map == NULL) */ DECLAREContigPutFunc(putRGBUAcontig16bittile) { int samplesperpixel = img->samplesperpixel; uint16 *wp = (uint16 *)pp; (void) y; fromskew *= samplesperpixel; while (h-- > 0) { uint32 r,g,b,a; /* * We shift alpha down four bits just in case unsigned * arithmetic doesn't handle the full range. * We still have plenty of accuracy, since the output is 8 bits. * So we have (r * 0xffff) * (a * 0xfff)) = r*a * (0xffff*0xfff) * Since we want r*a * 0xff for eight bit output, * we divide by (0xffff * 0xfff) / 0xff == 0x10eff. */ for (x = w; x-- > 0;) { a = wp[3] >> 4; r = (wp[0] * a) / 0x10eff; g = (wp[1] * a) / 0x10eff; b = (wp[2] * a) / 0x10eff; *cp++ = PACK4(r,g,b,a); wp += samplesperpixel; } cp += toskew; wp += fromskew; } } /* * 8-bit packed CMYK samples w/o Map => RGB * * NB: The conversion of CMYK->RGB is *very* crude. */ DECLAREContigPutFunc(putRGBcontig8bitCMYKtile) { int samplesperpixel = img->samplesperpixel; uint16 r, g, b, k; (void) x; (void) y; fromskew *= samplesperpixel; while (h-- > 0) { UNROLL8(w, NOP, k = 255 - pp[3]; r = (k*(255-pp[0]))/255; g = (k*(255-pp[1]))/255; b = (k*(255-pp[2]))/255; *cp++ = PACK(r, g, b); pp += samplesperpixel); cp += toskew; pp += fromskew; } } /* * 8-bit packed CMYK samples w/Map => RGB * * NB: The conversion of CMYK->RGB is *very* crude. */ DECLAREContigPutFunc(putRGBcontig8bitCMYKMaptile) { int samplesperpixel = img->samplesperpixel; TIFFRGBValue* Map = img->Map; uint16 r, g, b, k; (void) y; fromskew *= samplesperpixel; while (h-- > 0) { for (x = w; x-- > 0;) { k = 255 - pp[3]; r = (k*(255-pp[0]))/255; g = (k*(255-pp[1]))/255; b = (k*(255-pp[2]))/255; *cp++ = PACK(Map[r], Map[g], Map[b]); pp += samplesperpixel; } pp += fromskew; cp += toskew; } } #define DECLARESepPutFunc(name) \ static void name(\ TIFFRGBAImage* img,\ uint32* cp,\ uint32 x, uint32 y, \ uint32 w, uint32 h,\ int32 fromskew, int32 toskew,\ u_char* r, u_char* g, u_char* b, u_char* a\ ) /* * 8-bit unpacked samples => RGB */ DECLARESepPutFunc(putRGBseparate8bittile) { (void) img; (void) x; (void) y; (void) a; while (h-- > 0) { UNROLL8(w, NOP, *cp++ = PACK(*r++, *g++, *b++)); SKEW(r, g, b, fromskew); cp += toskew; } } /* * 8-bit unpacked samples => RGB */ DECLARESepPutFunc(putRGBseparate8bitMaptile) { TIFFRGBValue* Map = img->Map; (void) y; (void) a; while (h-- > 0) { for (x = w; x > 0; x--) *cp++ = PACK(Map[*r++], Map[*g++], Map[*b++]); SKEW(r, g, b, fromskew); cp += toskew; } } /* * 8-bit unpacked samples => RGBA w/ associated alpha */ DECLARESepPutFunc(putRGBAAseparate8bittile) { (void) img; (void) x; (void) y; while (h-- > 0) { UNROLL8(w, NOP, *cp++ = PACK4(*r++, *g++, *b++, *a++)); SKEW4(r, g, b, a, fromskew); cp += toskew; } } /* * 8-bit unpacked samples => RGBA w/ unassociated alpha */ DECLARESepPutFunc(putRGBUAseparate8bittile) { (void) img; (void) y; while (h-- > 0) { uint32 rv, gv, bv, av; for (x = w; x-- > 0;) { av = *a++; rv = (*r++ * av) / 255; gv = (*g++ * av) / 255; bv = (*b++ * av) / 255; *cp++ = PACK4(rv,gv,bv,av); } SKEW4(r, g, b, a, fromskew); cp += toskew; } } /* * 16-bit unpacked samples => RGB */ DECLARESepPutFunc(putRGBseparate16bittile) { uint16 *wr = (uint16*) r; uint16 *wg = (uint16*) g; uint16 *wb = (uint16*) b; (void) img; (void) y; (void) a; while (h-- > 0) { for (x = 0; x < w; x++) *cp++ = PACKW(*wr++, *wg++, *wb++); SKEW(wr, wg, wb, fromskew); cp += toskew; } } /* * 16-bit unpacked samples => RGBA w/ associated alpha */ DECLARESepPutFunc(putRGBAAseparate16bittile) { uint16 *wr = (uint16*) r; uint16 *wg = (uint16*) g; uint16 *wb = (uint16*) b; uint16 *wa = (uint16*) a; (void) img; (void) y; while (h-- > 0) { for (x = 0; x < w; x++) *cp++ = PACKW4(*wr++, *wg++, *wb++, *wa++); SKEW4(wr, wg, wb, wa, fromskew); cp += toskew; } } /* * 16-bit unpacked samples => RGBA w/ unassociated alpha */ DECLARESepPutFunc(putRGBUAseparate16bittile) { uint16 *wr = (uint16*) r; uint16 *wg = (uint16*) g; uint16 *wb = (uint16*) b; uint16 *wa = (uint16*) a; (void) img; (void) y; while (h-- > 0) { uint32 r,g,b,a; /* * We shift alpha down four bits just in case unsigned * arithmetic doesn't handle the full range. * We still have plenty of accuracy, since the output is 8 bits. * So we have (r * 0xffff) * (a * 0xfff)) = r*a * (0xffff*0xfff) * Since we want r*a * 0xff for eight bit output, * we divide by (0xffff * 0xfff) / 0xff == 0x10eff. */ for (x = w; x-- > 0;) { a = *wa++ >> 4; r = (*wr++ * a) / 0x10eff; g = (*wg++ * a) / 0x10eff; b = (*wb++ * a) / 0x10eff; *cp++ = PACK4(r,g,b,a); } SKEW4(wr, wg, wb, wa, fromskew); cp += toskew; } } /* * YCbCr -> RGB conversion and packing routines. The colorspace * conversion algorithm comes from the IJG v5a code; see below * for more information on how it works. */ #define YCbCrtoRGB(dst, yc) { \ int Y = (yc); \ dst = PACK( \ clamptab[Y+Crrtab[Cr]], \ clamptab[Y + (int)((Cbgtab[Cb]+Crgtab[Cr])>>16)], \ clamptab[Y+Cbbtab[Cb]]); \ } #define YCbCrSetup \ TIFFYCbCrToRGB* ycbcr = img->ycbcr; \ int* Crrtab = ycbcr->Cr_r_tab; \ int* Cbbtab = ycbcr->Cb_b_tab; \ int32* Crgtab = ycbcr->Cr_g_tab; \ int32* Cbgtab = ycbcr->Cb_g_tab; \ TIFFRGBValue* clamptab = ycbcr->clamptab /* * 8-bit packed YCbCr samples w/ 4,4 subsampling => RGB */ DECLAREContigPutFunc(putcontig8bitYCbCr44tile) { YCbCrSetup; uint32* cp1 = cp+w+toskew; uint32* cp2 = cp1+w+toskew; uint32* cp3 = cp2+w+toskew; int32 incr = 3*w+4*toskew; (void) y; /* XXX adjust fromskew */ for (; h >= 4; h -= 4) { x = w>>2; do { int Cb = pp[16]; int Cr = pp[17]; YCbCrtoRGB(cp [0], pp[ 0]); YCbCrtoRGB(cp [1], pp[ 1]); YCbCrtoRGB(cp [2], pp[ 2]); YCbCrtoRGB(cp [3], pp[ 3]); YCbCrtoRGB(cp1[0], pp[ 4]); YCbCrtoRGB(cp1[1], pp[ 5]); YCbCrtoRGB(cp1[2], pp[ 6]); YCbCrtoRGB(cp1[3], pp[ 7]); YCbCrtoRGB(cp2[0], pp[ 8]); YCbCrtoRGB(cp2[1], pp[ 9]); YCbCrtoRGB(cp2[2], pp[10]); YCbCrtoRGB(cp2[3], pp[11]); YCbCrtoRGB(cp3[0], pp[12]); YCbCrtoRGB(cp3[1], pp[13]); YCbCrtoRGB(cp3[2], pp[14]); YCbCrtoRGB(cp3[3], pp[15]); cp += 4, cp1 += 4, cp2 += 4, cp3 += 4; pp += 18; } while (--x); cp += incr, cp1 += incr, cp2 += incr, cp3 += incr; pp += fromskew; } } /* * 8-bit packed YCbCr samples w/ 4,2 subsampling => RGB */ DECLAREContigPutFunc(putcontig8bitYCbCr42tile) { YCbCrSetup; uint32* cp1 = cp+w+toskew; int32 incr = 2*toskew+w; (void) y; /* XXX adjust fromskew */ for (; h >= 2; h -= 2) { x = w>>2; do { int Cb = pp[8]; int Cr = pp[9]; YCbCrtoRGB(cp [0], pp[0]); YCbCrtoRGB(cp [1], pp[1]); YCbCrtoRGB(cp [2], pp[2]); YCbCrtoRGB(cp [3], pp[3]); YCbCrtoRGB(cp1[0], pp[4]); YCbCrtoRGB(cp1[1], pp[5]); YCbCrtoRGB(cp1[2], pp[6]); YCbCrtoRGB(cp1[3], pp[7]); cp += 4, cp1 += 4; pp += 10; } while (--x); cp += incr, cp1 += incr; pp += fromskew; } } /* * 8-bit packed YCbCr samples w/ 4,1 subsampling => RGB */ DECLAREContigPutFunc(putcontig8bitYCbCr41tile) { YCbCrSetup; (void) y; /* XXX adjust fromskew */ do { x = w>>2; do { int Cb = pp[4]; int Cr = pp[5]; YCbCrtoRGB(cp [0], pp[0]); YCbCrtoRGB(cp [1], pp[1]); YCbCrtoRGB(cp [2], pp[2]); YCbCrtoRGB(cp [3], pp[3]); cp += 4; pp += 6; } while (--x); cp += toskew; pp += fromskew; } while (--h); } /* * 8-bit packed YCbCr samples w/ 2,2 subsampling => RGB */ DECLAREContigPutFunc(putcontig8bitYCbCr22tile) { YCbCrSetup; uint32* cp1 = cp+w+toskew; int32 incr = 2*toskew+w; (void) y; /* XXX adjust fromskew */ for (; h >= 2; h -= 2) { x = w>>1; do { int Cb = pp[4]; int Cr = pp[5]; YCbCrtoRGB(cp [0], pp[0]); YCbCrtoRGB(cp [1], pp[1]); YCbCrtoRGB(cp1[0], pp[2]); YCbCrtoRGB(cp1[1], pp[3]); cp += 2, cp1 += 2; pp += 6; } while (--x); cp += incr, cp1 += incr; pp += fromskew; } } /* * 8-bit packed YCbCr samples w/ 2,1 subsampling => RGB */ DECLAREContigPutFunc(putcontig8bitYCbCr21tile) { YCbCrSetup; (void) y; /* XXX adjust fromskew */ do { x = w>>1; do { int Cb = pp[2]; int Cr = pp[3]; YCbCrtoRGB(cp[0], pp[0]); YCbCrtoRGB(cp[1], pp[1]); cp += 2; pp += 4; } while (--x); cp += toskew; pp += fromskew; } while (--h); } /* * 8-bit packed YCbCr samples w/ no subsampling => RGB */ DECLAREContigPutFunc(putcontig8bitYCbCr11tile) { YCbCrSetup; (void) y; /* XXX adjust fromskew */ do { x = w>>1; do { int Cb = pp[1]; int Cr = pp[2]; YCbCrtoRGB(*cp++, pp[0]); pp += 3; } while (--x); cp += toskew; pp += fromskew; } while (--h); } #undef YCbCrSetup #undef YCbCrtoRGB #define LumaRed coeffs[0] #define LumaGreen coeffs[1] #define LumaBlue coeffs[2] #define SHIFT 16 #define FIX(x) ((int32)((x) * (1L<RGB conversion tables. The conversion * is done according to the 6.0 spec: * * R = Y + Cr*(2 - 2*LumaRed) * B = Y + Cb*(2 - 2*LumaBlue) * G = Y * - LumaBlue*Cb*(2-2*LumaBlue)/LumaGreen * - LumaRed*Cr*(2-2*LumaRed)/LumaGreen * * To avoid floating point arithmetic the fractional constants that * come out of the equations are represented as fixed point values * in the range 0...2^16. We also eliminate multiplications by * pre-calculating possible values indexed by Cb and Cr (this code * assumes conversion is being done for 8-bit samples). */ static void TIFFYCbCrToRGBInit(TIFFYCbCrToRGB* ycbcr, TIFF* tif) { TIFFRGBValue* clamptab; float* coeffs; int i; clamptab = (TIFFRGBValue*)( (tidata_t) ycbcr+TIFFroundup(sizeof (TIFFYCbCrToRGB), sizeof (long))); _TIFFmemset(clamptab, 0, 256); /* v < 0 => 0 */ ycbcr->clamptab = (clamptab += 256); for (i = 0; i < 256; i++) clamptab[i] = i; _TIFFmemset(clamptab+256, 255, 2*256); /* v > 255 => 255 */ TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRCOEFFICIENTS, &coeffs); _TIFFmemcpy(ycbcr->coeffs, coeffs, 3*sizeof (float)); { float f1 = 2-2*LumaRed; int32 D1 = FIX(f1); float f2 = LumaRed*f1/LumaGreen; int32 D2 = -FIX(f2); float f3 = 2-2*LumaBlue; int32 D3 = FIX(f3); float f4 = LumaBlue*f3/LumaGreen; int32 D4 = -FIX(f4); int x; ycbcr->Cr_r_tab = (int*) (clamptab + 3*256); ycbcr->Cb_b_tab = ycbcr->Cr_r_tab + 256; ycbcr->Cr_g_tab = (int32*) (ycbcr->Cb_b_tab + 256); ycbcr->Cb_g_tab = ycbcr->Cr_g_tab + 256; /* * i is the actual input pixel value in the range 0..255 * Cb and Cr values are in the range -128..127 (actually * they are in a range defined by the ReferenceBlackWhite * tag) so there is some range shifting to do here when * constructing tables indexed by the raw pixel data. * * XXX handle ReferenceBlackWhite correctly to calculate * Cb/Cr values to use in constructing the tables. */ for (i = 0, x = -128; i < 256; i++, x++) { ycbcr->Cr_r_tab[i] = (int)((D1*x + ONE_HALF)>>SHIFT); ycbcr->Cb_b_tab[i] = (int)((D3*x + ONE_HALF)>>SHIFT); ycbcr->Cr_g_tab[i] = D2*x; ycbcr->Cb_g_tab[i] = D4*x + ONE_HALF; } } } #undef SHIFT #undef ONE_HALF #undef FIX #undef LumaBlue #undef LumaGreen #undef LumaRed static tileContigRoutine initYCbCrConversion(TIFFRGBAImage* img) { uint16 hs, vs; if (img->ycbcr == NULL) { img->ycbcr = (TIFFYCbCrToRGB*) _TIFFmalloc( TIFFroundup(sizeof (TIFFYCbCrToRGB), sizeof (long)) + 4*256*sizeof (TIFFRGBValue) + 2*256*sizeof (int) + 2*256*sizeof (int32) ); if (img->ycbcr == NULL) { TIFFError(TIFFFileName(img->tif), "No space for YCbCr->RGB conversion state"); return (NULL); } TIFFYCbCrToRGBInit(img->ycbcr, img->tif); } else { float* coeffs; TIFFGetFieldDefaulted(img->tif, TIFFTAG_YCBCRCOEFFICIENTS, &coeffs); if (_TIFFmemcmp(coeffs, img->ycbcr->coeffs, 3*sizeof (float)) != 0) TIFFYCbCrToRGBInit(img->ycbcr, img->tif); } /* * The 6.0 spec says that subsampling must be * one of 1, 2, or 4, and that vertical subsampling * must always be <= horizontal subsampling; so * there are only a few possibilities and we just * enumerate the cases. */ TIFFGetFieldDefaulted(img->tif, TIFFTAG_YCBCRSUBSAMPLING, &hs, &vs); switch ((hs<<4)|vs) { case 0x44: return (putcontig8bitYCbCr44tile); case 0x42: return (putcontig8bitYCbCr42tile); case 0x41: return (putcontig8bitYCbCr41tile); case 0x22: return (putcontig8bitYCbCr22tile); case 0x21: return (putcontig8bitYCbCr21tile); case 0x11: return (putcontig8bitYCbCr11tile); } return (NULL); } /* * Greyscale images with less than 8 bits/sample are handled * with a table to avoid lots of shifts and masks. The table * is setup so that put*bwtile (below) can retrieve 8/bitspersample * pixel values simply by indexing into the table with one * number. */ static int makebwmap(TIFFRGBAImage* img) { TIFFRGBValue* Map = img->Map; int bitspersample = img->bitspersample; int nsamples = 8 / bitspersample; int i; uint32* p; img->BWmap = (uint32**) _TIFFmalloc( 256*sizeof (uint32 *)+(256*nsamples*sizeof(uint32))); if (img->BWmap == NULL) { TIFFError(TIFFFileName(img->tif), "No space for B&W mapping table"); return (0); } p = (uint32*)(img->BWmap + 256); for (i = 0; i < 256; i++) { TIFFRGBValue c; img->BWmap[i] = p; switch (bitspersample) { #define GREY(x) c = Map[x]; *p++ = PACK(c,c,c); case 1: GREY(i>>7); GREY((i>>6)&1); GREY((i>>5)&1); GREY((i>>4)&1); GREY((i>>3)&1); GREY((i>>2)&1); GREY((i>>1)&1); GREY(i&1); break; case 2: GREY(i>>6); GREY((i>>4)&3); GREY((i>>2)&3); GREY(i&3); break; case 4: GREY(i>>4); GREY(i&0xf); break; case 8: GREY(i); break; } #undef GREY } return (1); } /* * Construct a mapping table to convert from the range * of the data samples to [0,255] --for display. This * process also handles inverting B&W images when needed. */ static int setupMap(TIFFRGBAImage* img) { int32 x, range; range = (int32)((1L<bitspersample)-1); img->Map = (TIFFRGBValue*) _TIFFmalloc((range+1) * sizeof (TIFFRGBValue)); if (img->Map == NULL) { TIFFError(TIFFFileName(img->tif), "No space for photometric conversion table"); return (0); } if (img->photometric == PHOTOMETRIC_MINISWHITE) { for (x = 0; x <= range; x++) img->Map[x] = (TIFFRGBValue) (((range - x) * 255) / range); } else { for (x = 0; x <= range; x++) img->Map[x] = (TIFFRGBValue) ((x * 255) / range); } if (img->bitspersample <= 8 && (img->photometric == PHOTOMETRIC_MINISBLACK || img->photometric == PHOTOMETRIC_MINISWHITE)) { /* * Use photometric mapping table to construct * unpacking tables for samples <= 8 bits. */ if (!makebwmap(img)) return (0); /* no longer need Map, free it */ _TIFFfree(img->Map), img->Map = NULL; } return (1); } static int checkcmap(TIFFRGBAImage* img) { uint16* r = img->redcmap; uint16* g = img->greencmap; uint16* b = img->bluecmap; long n = 1L<bitspersample; while (n-- > 0) if (*r++ >= 256 || *g++ >= 256 || *b++ >= 256) return (16); return (8); } static void cvtcmap(TIFFRGBAImage* img) { uint16* r = img->redcmap; uint16* g = img->greencmap; uint16* b = img->bluecmap; long i; for (i = (1L<bitspersample)-1; i >= 0; i--) { #define CVT(x) ((uint16)((x)>>8)) r[i] = CVT(r[i]); g[i] = CVT(g[i]); b[i] = CVT(b[i]); #undef CVT } } /* * Palette images with <= 8 bits/sample are handled * with a table to avoid lots of shifts and masks. The table * is setup so that put*cmaptile (below) can retrieve 8/bitspersample * pixel values simply by indexing into the table with one * number. */ static int makecmap(TIFFRGBAImage* img) { int bitspersample = img->bitspersample; int nsamples = 8 / bitspersample; uint16* r = img->redcmap; uint16* g = img->greencmap; uint16* b = img->bluecmap; uint32 *p; int i; img->PALmap = (uint32**) _TIFFmalloc( 256*sizeof (uint32 *)+(256*nsamples*sizeof(uint32))); if (img->PALmap == NULL) { TIFFError(TIFFFileName(img->tif), "No space for Palette mapping table"); return (0); } p = (uint32*)(img->PALmap + 256); for (i = 0; i < 256; i++) { TIFFRGBValue c; img->PALmap[i] = p; #define CMAP(x) c = x; *p++ = PACK(r[c]&0xff, g[c]&0xff, b[c]&0xff); switch (bitspersample) { case 1: CMAP(i>>7); CMAP((i>>6)&1); CMAP((i>>5)&1); CMAP((i>>4)&1); CMAP((i>>3)&1); CMAP((i>>2)&1); CMAP((i>>1)&1); CMAP(i&1); break; case 2: CMAP(i>>6); CMAP((i>>4)&3); CMAP((i>>2)&3); CMAP(i&3); break; case 4: CMAP(i>>4); CMAP(i&0xf); break; case 8: CMAP(i); break; } #undef CMAP } return (1); } /* * Construct any mapping table used * by the associated put routine. */ static int buildMap(TIFFRGBAImage* img) { switch (img->photometric) { case PHOTOMETRIC_RGB: case PHOTOMETRIC_YCBCR: case PHOTOMETRIC_SEPARATED: if (img->bitspersample == 8) break; /* fall thru... */ case PHOTOMETRIC_MINISBLACK: case PHOTOMETRIC_MINISWHITE: if (!setupMap(img)) return (0); break; case PHOTOMETRIC_PALETTE: /* * Convert 16-bit colormap to 8-bit (unless it looks * like an old-style 8-bit colormap). */ if (checkcmap(img) == 16) cvtcmap(img); else TIFFWarning(TIFFFileName(img->tif), "Assuming 8-bit colormap"); /* * Use mapping table and colormap to construct * unpacking tables for samples < 8 bits. */ if (img->bitspersample <= 8 && !makecmap(img)) return (0); break; } return (1); } /* * Select the appropriate conversion routine for packed data. */ static int pickTileContigCase(TIFFRGBAImage* img) { tileContigRoutine put = 0; if (buildMap(img)) { switch (img->photometric) { case PHOTOMETRIC_RGB: switch (img->bitspersample) { case 8: if (!img->Map) { if (img->alpha == EXTRASAMPLE_ASSOCALPHA) put = putRGBAAcontig8bittile; else if (img->alpha == EXTRASAMPLE_UNASSALPHA) put = putRGBUAcontig8bittile; else put = putRGBcontig8bittile; } else put = putRGBcontig8bitMaptile; break; case 16: put = putRGBcontig16bittile; if (!img->Map) { if (img->alpha == EXTRASAMPLE_ASSOCALPHA) put = putRGBAAcontig16bittile; else if (img->alpha == EXTRASAMPLE_UNASSALPHA) put = putRGBUAcontig16bittile; } break; } break; case PHOTOMETRIC_SEPARATED: if (img->bitspersample == 8) { if (!img->Map) put = putRGBcontig8bitCMYKtile; else put = putRGBcontig8bitCMYKMaptile; } break; case PHOTOMETRIC_PALETTE: switch (img->bitspersample) { case 8: put = put8bitcmaptile; break; case 4: put = put4bitcmaptile; break; case 2: put = put2bitcmaptile; break; case 1: put = put1bitcmaptile; break; } break; case PHOTOMETRIC_MINISWHITE: case PHOTOMETRIC_MINISBLACK: switch (img->bitspersample) { case 8: put = putgreytile; break; case 4: put = put4bitbwtile; break; case 2: put = put2bitbwtile; break; case 1: put = put1bitbwtile; break; } break; case PHOTOMETRIC_YCBCR: if (img->bitspersample == 8) put = initYCbCrConversion(img); break; } } return ((img->put.contig = put) != 0); } /* * Select the appropriate conversion routine for unpacked data. * * NB: we assume that unpacked single channel data is directed * to the "packed routines. */ static int pickTileSeparateCase(TIFFRGBAImage* img) { tileSeparateRoutine put = 0; if (buildMap(img)) { switch (img->photometric) { case PHOTOMETRIC_RGB: switch (img->bitspersample) { case 8: if (!img->Map) { if (img->alpha == EXTRASAMPLE_ASSOCALPHA) put = putRGBAAseparate8bittile; else if (img->alpha == EXTRASAMPLE_UNASSALPHA) put = putRGBUAseparate8bittile; else put = putRGBseparate8bittile; } else put = putRGBseparate8bitMaptile; break; case 16: put = putRGBseparate16bittile; if (!img->Map) { if (img->alpha == EXTRASAMPLE_ASSOCALPHA) put = putRGBAAseparate16bittile; else if (img->alpha == EXTRASAMPLE_UNASSALPHA) put = putRGBUAseparate16bittile; } break; } break; } } return ((img->put.separate = put) != 0); } /* * Read a whole strip off data from the file, and convert to RGBA form. * If this is the last strip, then it will only contain the portion of * the strip that is actually within the image space. The result is * organized in bottom to top form. */ int TIFFReadRGBAStrip(TIFF* tif, uint32 row, uint32 * raster ) { char emsg[1024]; TIFFRGBAImage img; int ok; uint32 rowsperstrip, rows_to_read; if( TIFFIsTiled( tif ) ) { TIFFError(TIFFFileName(tif), "Can't use TIFFReadRGBAStrip() with tiled file."); return (0); } TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip); if( (row % rowsperstrip) != 0 ) { TIFFError(TIFFFileName(tif), "Row passed to TIFFReadRGBAStrip() must be first in a strip."); return (0); } if (TIFFRGBAImageBegin(&img, tif, 0, emsg)) { img.row_offset = row; img.col_offset = 0; if( row + rowsperstrip > img.height ) rows_to_read = img.height - row; else rows_to_read = rowsperstrip; ok = TIFFRGBAImageGet(&img, raster, img.width, rows_to_read ); TIFFRGBAImageEnd(&img); } else { TIFFError(TIFFFileName(tif), emsg); ok = 0; } return (ok); } /* * Read a whole tile off data from the file, and convert to RGBA form. * The returned RGBA data is organized from bottom to top of tile, * and may include zeroed areas if the tile extends off the image. */ int TIFFReadRGBATile(TIFF* tif, uint32 col, uint32 row, uint32 * raster) { char emsg[1024]; TIFFRGBAImage img; int ok; uint32 tile_xsize, tile_ysize; uint32 read_xsize, read_ysize; uint32 i_row; /* * Verify that our request is legal - on a tile file, and on a * tile boundary. */ if( !TIFFIsTiled( tif ) ) { TIFFError(TIFFFileName(tif), "Can't use TIFFReadRGBATile() with stripped file."); return (0); } TIFFGetFieldDefaulted(tif, TIFFTAG_TILEWIDTH, &tile_xsize); TIFFGetFieldDefaulted(tif, TIFFTAG_TILELENGTH, &tile_ysize); if( (col % tile_xsize) != 0 || (row % tile_ysize) != 0 ) { TIFFError(TIFFFileName(tif), "Row/col passed to TIFFReadRGBATile() must be top" "left corner of a tile."); return (0); } /* * Setup the RGBA reader. */ if ( !TIFFRGBAImageBegin(&img, tif, 0, emsg)) { TIFFError(TIFFFileName(tif), emsg); return( 0 ); } /* * The TIFFRGBAImageGet() function doesn't allow us to get off the * edge of the image, even to fill an otherwise valid tile. So we * figure out how much we can read, and fix up the tile buffer to * a full tile configuration afterwards. */ if( row + tile_ysize > img.height ) read_ysize = img.height - row; else read_ysize = tile_ysize; if( col + tile_xsize > img.width ) read_xsize = img.width - col; else read_xsize = tile_xsize; /* * Read the chunk of imagery. */ img.row_offset = row; img.col_offset = col; ok = TIFFRGBAImageGet(&img, raster, read_xsize, read_ysize ); TIFFRGBAImageEnd(&img); /* * If our read was incomplete we will need to fix up the tile by * shifting the data around as if a full tile of data is being returned. * * This is all the more complicated because the image is organized in * bottom to top format. */ if( read_xsize == tile_xsize && read_ysize == tile_ysize ) return( ok ); for( i_row = 0; i_row < read_ysize; i_row++ ) { _TIFFmemcpy( raster + (tile_ysize - i_row - 1) * tile_xsize, raster + (read_ysize - i_row - 1) * read_xsize, read_xsize * sizeof(uint32) ); _TIFFmemset( raster + (tile_ysize - i_row - 1) * tile_xsize+read_xsize, 0, sizeof(uint32) * (tile_xsize - read_xsize) ); } for( i_row = read_ysize; i_row < tile_ysize; i_row++ ) { _TIFFmemset( raster + (tile_ysize - i_row - 1) * tile_xsize, 0, sizeof(uint32) * tile_xsize ); } return (ok); } netpbm-8.2/libtiff/tif_jpeg.c0100660000076400000000000012204307020047062015237 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_jpeg.c,v 1.2 1999/11/27 21:33:38 warmerda Exp $ */ /* * Copyright (c) 1994-1997 Sam Leffler * Copyright (c) 1994-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #include "tiffiop.h" #ifdef JPEG_SUPPORT /* * TIFF Library * * JPEG Compression support per TIFF Technical Note #2 * (*not* per the original TIFF 6.0 spec). * * This file is simply an interface to the libjpeg library written by * the Independent JPEG Group. You need release 5 or later of the IJG * code, which you can find on the Internet at ftp.uu.net:/graphics/jpeg/. * * Contributed by Tom Lane . */ #include #include #include /* We undefine FAR to avoid conflict with JPEG definition */ #ifdef FAR #undef FAR #endif #include "jpeglib.h" #include "jerror.h" /* * On some machines it may be worthwhile to use _setjmp or sigsetjmp * in place of plain setjmp. These macros will make it easier. */ #define SETJMP(jbuf) setjmp(jbuf) #define LONGJMP(jbuf,code) longjmp(jbuf,code) #define JMP_BUF jmp_buf typedef struct jpeg_destination_mgr jpeg_destination_mgr; typedef struct jpeg_source_mgr jpeg_source_mgr; typedef struct jpeg_error_mgr jpeg_error_mgr; /* * State block for each open TIFF file using * libjpeg to do JPEG compression/decompression. * * libjpeg's visible state is either a jpeg_compress_struct * or jpeg_decompress_struct depending on which way we * are going. comm can be used to refer to the fields * which are common to both. * * NB: cinfo is required to be the first member of JPEGState, * so we can safely cast JPEGState* -> jpeg_xxx_struct* * and vice versa! */ typedef struct { union { struct jpeg_compress_struct c; struct jpeg_decompress_struct d; struct jpeg_common_struct comm; } cinfo; /* NB: must be first */ jpeg_error_mgr err; /* libjpeg error manager */ JMP_BUF exit_jmpbuf; /* for catching libjpeg failures */ /* * The following two members could be a union, but * they're small enough that it's not worth the effort. */ jpeg_destination_mgr dest; /* data dest for compression */ jpeg_source_mgr src; /* data source for decompression */ /* private state */ TIFF* tif; /* back link needed by some code */ uint16 photometric; /* copy of PhotometricInterpretation */ uint16 h_sampling; /* luminance sampling factors */ uint16 v_sampling; tsize_t bytesperline; /* decompressed bytes per scanline */ /* pointers to intermediate buffers when processing downsampled data */ JSAMPARRAY ds_buffer[MAX_COMPONENTS]; int scancount; /* number of "scanlines" accumulated */ int samplesperclump; TIFFVGetMethod vgetparent; /* super-class method */ TIFFVSetMethod vsetparent; /* super-class method */ TIFFStripMethod defsparent; /* super-class method */ TIFFTileMethod deftparent; /* super-class method */ /* pseudo-tag fields */ void* jpegtables; /* JPEGTables tag value, or NULL */ uint32 jpegtables_length; /* number of bytes in same */ int jpegquality; /* Compression quality level */ int jpegcolormode; /* Auto RGB<=>YCbCr convert? */ int jpegtablesmode; /* What to put in JPEGTables */ } JPEGState; #define JState(tif) ((JPEGState*)(tif)->tif_data) static int JPEGDecode(TIFF*, tidata_t, tsize_t, tsample_t); static int JPEGDecodeRaw(TIFF*, tidata_t, tsize_t, tsample_t); static int JPEGEncode(TIFF*, tidata_t, tsize_t, tsample_t); static int JPEGEncodeRaw(TIFF*, tidata_t, tsize_t, tsample_t); #define FIELD_JPEGTABLES (FIELD_CODEC+0) static const TIFFFieldInfo jpegFieldInfo[] = { { TIFFTAG_JPEGTABLES, -1,-1, TIFF_UNDEFINED, FIELD_JPEGTABLES, FALSE, TRUE, "JPEGTables" }, { TIFFTAG_JPEGQUALITY, 0, 0, TIFF_ANY, FIELD_PSEUDO, TRUE, FALSE, "" }, { TIFFTAG_JPEGCOLORMODE, 0, 0, TIFF_ANY, FIELD_PSEUDO, FALSE, FALSE, "" }, { TIFFTAG_JPEGTABLESMODE, 0, 0, TIFF_ANY, FIELD_PSEUDO, FALSE, FALSE, "" }, }; #define N(a) (sizeof (a) / sizeof (a[0])) /* * libjpeg interface layer. * * We use setjmp/longjmp to return control to libtiff * when a fatal error is encountered within the JPEG * library. We also direct libjpeg error and warning * messages through the appropriate libtiff handlers. */ /* * Error handling routines (these replace corresponding * IJG routines from jerror.c). These are used for both * compression and decompression. */ static void TIFFjpeg_error_exit(j_common_ptr cinfo) { JPEGState *sp = (JPEGState *) cinfo; /* NB: cinfo assumed first */ char buffer[JMSG_LENGTH_MAX]; (*cinfo->err->format_message) (cinfo, buffer); TIFFError("JPEGLib", buffer); /* display the error message */ jpeg_abort(cinfo); /* clean up libjpeg state */ LONGJMP(sp->exit_jmpbuf, 1); /* return to libtiff caller */ } /* * This routine is invoked only for warning messages, * since error_exit does its own thing and trace_level * is never set > 0. */ static void TIFFjpeg_output_message(j_common_ptr cinfo) { char buffer[JMSG_LENGTH_MAX]; (*cinfo->err->format_message) (cinfo, buffer); TIFFWarning("JPEGLib", buffer); } /* * Interface routines. This layer of routines exists * primarily to limit side-effects from using setjmp. * Also, normal/error returns are converted into return * values per libtiff practice. */ #define CALLJPEG(sp, fail, op) (SETJMP((sp)->exit_jmpbuf) ? (fail) : (op)) #define CALLVJPEG(sp, op) CALLJPEG(sp, 0, ((op),1)) static int TIFFjpeg_create_compress(JPEGState* sp) { /* initialize JPEG error handling */ sp->cinfo.c.err = jpeg_std_error(&sp->err); sp->err.error_exit = TIFFjpeg_error_exit; sp->err.output_message = TIFFjpeg_output_message; return CALLVJPEG(sp, jpeg_create_compress(&sp->cinfo.c)); } static int TIFFjpeg_create_decompress(JPEGState* sp) { /* initialize JPEG error handling */ sp->cinfo.d.err = jpeg_std_error(&sp->err); sp->err.error_exit = TIFFjpeg_error_exit; sp->err.output_message = TIFFjpeg_output_message; return CALLVJPEG(sp, jpeg_create_decompress(&sp->cinfo.d)); } static int TIFFjpeg_set_defaults(JPEGState* sp) { return CALLVJPEG(sp, jpeg_set_defaults(&sp->cinfo.c)); } static int TIFFjpeg_set_colorspace(JPEGState* sp, J_COLOR_SPACE colorspace) { return CALLVJPEG(sp, jpeg_set_colorspace(&sp->cinfo.c, colorspace)); } static int TIFFjpeg_set_quality(JPEGState* sp, int quality, boolean force_baseline) { return CALLVJPEG(sp, jpeg_set_quality(&sp->cinfo.c, quality, force_baseline)); } static int TIFFjpeg_suppress_tables(JPEGState* sp, boolean suppress) { return CALLVJPEG(sp, jpeg_suppress_tables(&sp->cinfo.c, suppress)); } static int TIFFjpeg_start_compress(JPEGState* sp, boolean write_all_tables) { return CALLVJPEG(sp, jpeg_start_compress(&sp->cinfo.c, write_all_tables)); } static int TIFFjpeg_write_scanlines(JPEGState* sp, JSAMPARRAY scanlines, int num_lines) { return CALLJPEG(sp, -1, (int) jpeg_write_scanlines(&sp->cinfo.c, scanlines, (JDIMENSION) num_lines)); } static int TIFFjpeg_write_raw_data(JPEGState* sp, JSAMPIMAGE data, int num_lines) { return CALLJPEG(sp, -1, (int) jpeg_write_raw_data(&sp->cinfo.c, data, (JDIMENSION) num_lines)); } static int TIFFjpeg_finish_compress(JPEGState* sp) { return CALLVJPEG(sp, jpeg_finish_compress(&sp->cinfo.c)); } static int TIFFjpeg_write_tables(JPEGState* sp) { return CALLVJPEG(sp, jpeg_write_tables(&sp->cinfo.c)); } static int TIFFjpeg_read_header(JPEGState* sp, boolean require_image) { return CALLJPEG(sp, -1, jpeg_read_header(&sp->cinfo.d, require_image)); } static int TIFFjpeg_start_decompress(JPEGState* sp) { return CALLVJPEG(sp, jpeg_start_decompress(&sp->cinfo.d)); } static int TIFFjpeg_read_scanlines(JPEGState* sp, JSAMPARRAY scanlines, int max_lines) { return CALLJPEG(sp, -1, (int) jpeg_read_scanlines(&sp->cinfo.d, scanlines, (JDIMENSION) max_lines)); } static int TIFFjpeg_read_raw_data(JPEGState* sp, JSAMPIMAGE data, int max_lines) { return CALLJPEG(sp, -1, (int) jpeg_read_raw_data(&sp->cinfo.d, data, (JDIMENSION) max_lines)); } static int TIFFjpeg_finish_decompress(JPEGState* sp) { return CALLJPEG(sp, -1, (int) jpeg_finish_decompress(&sp->cinfo.d)); } static int TIFFjpeg_abort(JPEGState* sp) { return CALLVJPEG(sp, jpeg_abort(&sp->cinfo.comm)); } static int TIFFjpeg_destroy(JPEGState* sp) { return CALLVJPEG(sp, jpeg_destroy(&sp->cinfo.comm)); } static JSAMPARRAY TIFFjpeg_alloc_sarray(JPEGState* sp, int pool_id, JDIMENSION samplesperrow, JDIMENSION numrows) { return CALLJPEG(sp, (JSAMPARRAY) NULL, (*sp->cinfo.comm.mem->alloc_sarray) (&sp->cinfo.comm, pool_id, samplesperrow, numrows)); } /* * JPEG library destination data manager. * These routines direct compressed data from libjpeg into the * libtiff output buffer. */ static void std_init_destination(j_compress_ptr cinfo) { JPEGState* sp = (JPEGState*) cinfo; TIFF* tif = sp->tif; sp->dest.next_output_byte = (JOCTET*) tif->tif_rawdata; sp->dest.free_in_buffer = (size_t) tif->tif_rawdatasize; } static boolean std_empty_output_buffer(j_compress_ptr cinfo) { JPEGState* sp = (JPEGState*) cinfo; TIFF* tif = sp->tif; /* the entire buffer has been filled */ tif->tif_rawcc = tif->tif_rawdatasize; TIFFFlushData1(tif); sp->dest.next_output_byte = (JOCTET*) tif->tif_rawdata; sp->dest.free_in_buffer = (size_t) tif->tif_rawdatasize; return (TRUE); } static void std_term_destination(j_compress_ptr cinfo) { JPEGState* sp = (JPEGState*) cinfo; TIFF* tif = sp->tif; tif->tif_rawcp = (tidata_t) sp->dest.next_output_byte; tif->tif_rawcc = tif->tif_rawdatasize - (tsize_t) sp->dest.free_in_buffer; /* NB: libtiff does the final buffer flush */ } static void TIFFjpeg_data_dest(JPEGState* sp, TIFF* tif) { (void) tif; sp->cinfo.c.dest = &sp->dest; sp->dest.init_destination = std_init_destination; sp->dest.empty_output_buffer = std_empty_output_buffer; sp->dest.term_destination = std_term_destination; } /* * Alternate destination manager for outputting to JPEGTables field. */ static void tables_init_destination(j_compress_ptr cinfo) { JPEGState* sp = (JPEGState*) cinfo; /* while building, jpegtables_length is allocated buffer size */ sp->dest.next_output_byte = (JOCTET*) sp->jpegtables; sp->dest.free_in_buffer = (size_t) sp->jpegtables_length; } static boolean tables_empty_output_buffer(j_compress_ptr cinfo) { JPEGState* sp = (JPEGState*) cinfo; void* newbuf; /* the entire buffer has been filled; enlarge it by 1000 bytes */ newbuf = _TIFFrealloc((tdata_t) sp->jpegtables, (tsize_t) (sp->jpegtables_length + 1000)); if (newbuf == NULL) ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 100); sp->dest.next_output_byte = (JOCTET*) newbuf + sp->jpegtables_length; sp->dest.free_in_buffer = (size_t) 1000; sp->jpegtables = newbuf; sp->jpegtables_length += 1000; return (TRUE); } static void tables_term_destination(j_compress_ptr cinfo) { JPEGState* sp = (JPEGState*) cinfo; /* set tables length to number of bytes actually emitted */ sp->jpegtables_length -= sp->dest.free_in_buffer; } static int TIFFjpeg_tables_dest(JPEGState* sp, TIFF* tif) { (void) tif; /* * Allocate a working buffer for building tables. * Initial size is 1000 bytes, which is usually adequate. */ if (sp->jpegtables) _TIFFfree(sp->jpegtables); sp->jpegtables_length = 1000; sp->jpegtables = (void*) _TIFFmalloc((tsize_t) sp->jpegtables_length); if (sp->jpegtables == NULL) { sp->jpegtables_length = 0; TIFFError("TIFFjpeg_tables_dest", "No space for JPEGTables"); return (0); } sp->cinfo.c.dest = &sp->dest; sp->dest.init_destination = tables_init_destination; sp->dest.empty_output_buffer = tables_empty_output_buffer; sp->dest.term_destination = tables_term_destination; return (1); } /* * JPEG library source data manager. * These routines supply compressed data to libjpeg. */ static void std_init_source(j_decompress_ptr cinfo) { JPEGState* sp = (JPEGState*) cinfo; TIFF* tif = sp->tif; sp->src.next_input_byte = (const JOCTET*) tif->tif_rawdata; sp->src.bytes_in_buffer = (size_t) tif->tif_rawcc; } static boolean std_fill_input_buffer(j_decompress_ptr cinfo) { JPEGState* sp = (JPEGState* ) cinfo; static const JOCTET dummy_EOI[2] = { 0xFF, JPEG_EOI }; /* * Should never get here since entire strip/tile is * read into memory before the decompressor is called, * and thus was supplied by init_source. */ WARNMS(cinfo, JWRN_JPEG_EOF); /* insert a fake EOI marker */ sp->src.next_input_byte = dummy_EOI; sp->src.bytes_in_buffer = 2; return (TRUE); } static void std_skip_input_data(j_decompress_ptr cinfo, long num_bytes) { JPEGState* sp = (JPEGState*) cinfo; if (num_bytes > 0) { if (num_bytes > (long) sp->src.bytes_in_buffer) { /* oops, buffer overrun */ (void) std_fill_input_buffer(cinfo); } else { sp->src.next_input_byte += (size_t) num_bytes; sp->src.bytes_in_buffer -= (size_t) num_bytes; } } } static void std_term_source(j_decompress_ptr cinfo) { /* No work necessary here */ /* Or must we update tif->tif_rawcp, tif->tif_rawcc ??? */ /* (if so, need empty tables_term_source!) */ (void) cinfo; } static void TIFFjpeg_data_src(JPEGState* sp, TIFF* tif) { (void) tif; sp->cinfo.d.src = &sp->src; sp->src.init_source = std_init_source; sp->src.fill_input_buffer = std_fill_input_buffer; sp->src.skip_input_data = std_skip_input_data; sp->src.resync_to_restart = jpeg_resync_to_restart; sp->src.term_source = std_term_source; sp->src.bytes_in_buffer = 0; /* for safety */ sp->src.next_input_byte = NULL; } /* * Alternate source manager for reading from JPEGTables. * We can share all the code except for the init routine. */ static void tables_init_source(j_decompress_ptr cinfo) { JPEGState* sp = (JPEGState*) cinfo; sp->src.next_input_byte = (const JOCTET*) sp->jpegtables; sp->src.bytes_in_buffer = (size_t) sp->jpegtables_length; } static void TIFFjpeg_tables_src(JPEGState* sp, TIFF* tif) { TIFFjpeg_data_src(sp, tif); sp->src.init_source = tables_init_source; } /* * Allocate downsampled-data buffers needed for downsampled I/O. * We use values computed in jpeg_start_compress or jpeg_start_decompress. * We use libjpeg's allocator so that buffers will be released automatically * when done with strip/tile. * This is also a handy place to compute samplesperclump, bytesperline. */ static int alloc_downsampled_buffers(TIFF* tif, jpeg_component_info* comp_info, int num_components) { JPEGState* sp = JState(tif); int ci; jpeg_component_info* compptr; JSAMPARRAY buf; int samples_per_clump = 0; for (ci = 0, compptr = comp_info; ci < num_components; ci++, compptr++) { samples_per_clump += compptr->h_samp_factor * compptr->v_samp_factor; buf = TIFFjpeg_alloc_sarray(sp, JPOOL_IMAGE, compptr->width_in_blocks * DCTSIZE, (JDIMENSION) (compptr->v_samp_factor*DCTSIZE)); if (buf == NULL) return (0); sp->ds_buffer[ci] = buf; } sp->samplesperclump = samples_per_clump; /* Cb,Cr both have sampling factors 1 */ /* so downsampled width of Cb is # of clumps per line */ sp->bytesperline = sizeof(JSAMPLE) * samples_per_clump * comp_info[1].downsampled_width; return (1); } /* * JPEG Decoding. */ static int JPEGSetupDecode(TIFF* tif) { JPEGState* sp = JState(tif); TIFFDirectory *td = &tif->tif_dir; assert(sp != NULL); assert(sp->cinfo.comm.is_decompressor); /* Read JPEGTables if it is present */ if (TIFFFieldSet(tif,FIELD_JPEGTABLES)) { TIFFjpeg_tables_src(sp, tif); if(TIFFjpeg_read_header(sp,FALSE) != JPEG_HEADER_TABLES_ONLY) { TIFFError("JPEGSetupDecode", "Bogus JPEGTables field"); return (0); } } /* Grab parameters that are same for all strips/tiles */ sp->photometric = td->td_photometric; switch (sp->photometric) { case PHOTOMETRIC_YCBCR: sp->h_sampling = td->td_ycbcrsubsampling[0]; sp->v_sampling = td->td_ycbcrsubsampling[1]; break; default: /* TIFF 6.0 forbids subsampling of all other color spaces */ sp->h_sampling = 1; sp->v_sampling = 1; break; } /* Set up for reading normal data */ TIFFjpeg_data_src(sp, tif); tif->tif_postdecode = _TIFFNoPostDecode; /* override byte swapping */ return (1); } /* * Set up for decoding a strip or tile. */ static int JPEGPreDecode(TIFF* tif, tsample_t s) { JPEGState *sp = JState(tif); TIFFDirectory *td = &tif->tif_dir; static const char module[] = "JPEGPreDecode"; uint32 segment_width, segment_height; int downsampled_output; int ci; assert(sp != NULL); assert(sp->cinfo.comm.is_decompressor); /* * Reset decoder state from any previous strip/tile, * in case application didn't read the whole strip. */ if (!TIFFjpeg_abort(sp)) return (0); /* * Read the header for this strip/tile. */ if (TIFFjpeg_read_header(sp, TRUE) != JPEG_HEADER_OK) return (0); /* * Check image parameters and set decompression parameters. */ if (isTiled(tif)) { segment_width = td->td_tilewidth; segment_height = td->td_tilelength; sp->bytesperline = TIFFTileRowSize(tif); } else { segment_width = td->td_imagewidth; segment_height = td->td_imagelength - tif->tif_row; if (segment_height > td->td_rowsperstrip) segment_height = td->td_rowsperstrip; sp->bytesperline = TIFFScanlineSize(tif); } if (td->td_planarconfig == PLANARCONFIG_SEPARATE && s > 0) { /* * For PC 2, scale down the expected strip/tile size * to match a downsampled component */ segment_width = TIFFhowmany(segment_width, sp->h_sampling); segment_height = TIFFhowmany(segment_height, sp->v_sampling); } if (sp->cinfo.d.image_width != segment_width || sp->cinfo.d.image_height != segment_height) { TIFFError(module, "Improper JPEG strip/tile size"); return (0); } if (sp->cinfo.d.num_components != (td->td_planarconfig == PLANARCONFIG_CONTIG ? td->td_samplesperpixel : 1)) { TIFFError(module, "Improper JPEG component count"); return (0); } if (sp->cinfo.d.data_precision != td->td_bitspersample) { TIFFError(module, "Improper JPEG data precision"); return (0); } if (td->td_planarconfig == PLANARCONFIG_CONTIG) { /* Component 0 should have expected sampling factors */ if (sp->cinfo.d.comp_info[0].h_samp_factor != sp->h_sampling || sp->cinfo.d.comp_info[0].v_samp_factor != sp->v_sampling) { TIFFError(module, "Improper JPEG sampling factors"); return (0); } /* Rest should have sampling factors 1,1 */ for (ci = 1; ci < sp->cinfo.d.num_components; ci++) { if (sp->cinfo.d.comp_info[ci].h_samp_factor != 1 || sp->cinfo.d.comp_info[ci].v_samp_factor != 1) { TIFFError(module, "Improper JPEG sampling factors"); return (0); } } } else { /* PC 2's single component should have sampling factors 1,1 */ if (sp->cinfo.d.comp_info[0].h_samp_factor != 1 || sp->cinfo.d.comp_info[0].v_samp_factor != 1) { TIFFError(module, "Improper JPEG sampling factors"); return (0); } } downsampled_output = FALSE; if (td->td_planarconfig == PLANARCONFIG_CONTIG && sp->photometric == PHOTOMETRIC_YCBCR && sp->jpegcolormode == JPEGCOLORMODE_RGB) { /* Convert YCbCr to RGB */ sp->cinfo.d.jpeg_color_space = JCS_YCbCr; sp->cinfo.d.out_color_space = JCS_RGB; } else { /* Suppress colorspace handling */ sp->cinfo.d.jpeg_color_space = JCS_UNKNOWN; sp->cinfo.d.out_color_space = JCS_UNKNOWN; if (td->td_planarconfig == PLANARCONFIG_CONTIG && (sp->h_sampling != 1 || sp->v_sampling != 1)) downsampled_output = TRUE; /* XXX what about up-sampling? */ } if (downsampled_output) { /* Need to use raw-data interface to libjpeg */ sp->cinfo.d.raw_data_out = TRUE; tif->tif_decoderow = JPEGDecodeRaw; tif->tif_decodestrip = JPEGDecodeRaw; tif->tif_decodetile = JPEGDecodeRaw; } else { /* Use normal interface to libjpeg */ sp->cinfo.d.raw_data_out = FALSE; tif->tif_decoderow = JPEGDecode; tif->tif_decodestrip = JPEGDecode; tif->tif_decodetile = JPEGDecode; } /* Start JPEG decompressor */ if (!TIFFjpeg_start_decompress(sp)) return (0); /* Allocate downsampled-data buffers if needed */ if (downsampled_output) { if (!alloc_downsampled_buffers(tif, sp->cinfo.d.comp_info, sp->cinfo.d.num_components)) return (0); sp->scancount = DCTSIZE; /* mark buffer empty */ } return (1); } /* * Decode a chunk of pixels. * "Standard" case: returned data is not downsampled. */ static int JPEGDecode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) { JPEGState *sp = JState(tif); tsize_t nrows; JSAMPROW bufptr[1]; (void) s; assert(sp != NULL); /* data is expected to be read in multiples of a scanline */ nrows = cc / sp->bytesperline; if (cc % sp->bytesperline) TIFFWarning(tif->tif_name, "fractional scanline not read"); while (nrows-- > 0) { bufptr[0] = (JSAMPROW) buf; if (TIFFjpeg_read_scanlines(sp, bufptr, 1) != 1) return (0); if (nrows > 0) tif->tif_row++; buf += sp->bytesperline; } /* Close down the decompressor if we've finished the strip or tile. */ if (sp->cinfo.d.output_scanline == sp->cinfo.d.output_height) { if (TIFFjpeg_finish_decompress(sp) != TRUE) return (0); } return (1); } /* * Decode a chunk of pixels. * Returned data is downsampled per sampling factors. */ static int JPEGDecodeRaw(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) { JPEGState *sp = JState(tif); JSAMPLE* inptr; JSAMPLE* outptr; tsize_t nrows; JDIMENSION clumps_per_line, nclump; int clumpoffset, ci, xpos, ypos; jpeg_component_info* compptr; int samples_per_clump = sp->samplesperclump; (void) s; assert(sp != NULL); /* data is expected to be read in multiples of a scanline */ nrows = cc / sp->bytesperline; if (cc % sp->bytesperline) TIFFWarning(tif->tif_name, "fractional scanline not read"); /* Cb,Cr both have sampling factors 1, so this is correct */ clumps_per_line = sp->cinfo.d.comp_info[1].downsampled_width; while (nrows-- > 0) { /* Reload downsampled-data buffer if needed */ if (sp->scancount >= DCTSIZE) { int n = sp->cinfo.d.max_v_samp_factor * DCTSIZE; if (TIFFjpeg_read_raw_data(sp, sp->ds_buffer, n) != n) return (0); sp->scancount = 0; /* Close down the decompressor if done. */ if (sp->cinfo.d.output_scanline >= sp->cinfo.d.output_height) { if (TIFFjpeg_finish_decompress(sp) != TRUE) return (0); } } /* * Fastest way to unseparate the data is to make one pass * over the scanline for each row of each component. */ clumpoffset = 0; /* first sample in clump */ for (ci = 0, compptr = sp->cinfo.d.comp_info; ci < sp->cinfo.d.num_components; ci++, compptr++) { int hsamp = compptr->h_samp_factor; int vsamp = compptr->v_samp_factor; for (ypos = 0; ypos < vsamp; ypos++) { inptr = sp->ds_buffer[ci][sp->scancount*vsamp + ypos]; outptr = ((JSAMPLE*) buf) + clumpoffset; if (hsamp == 1) { /* fast path for at least Cb and Cr */ for (nclump = clumps_per_line; nclump-- > 0; ) { outptr[0] = *inptr++; outptr += samples_per_clump; } } else { /* general case */ for (nclump = clumps_per_line; nclump-- > 0; ) { for (xpos = 0; xpos < hsamp; xpos++) outptr[xpos] = *inptr++; outptr += samples_per_clump; } } clumpoffset += hsamp; } } sp->scancount++; if (nrows > 0) tif->tif_row++; buf += sp->bytesperline; } return (1); } /* * JPEG Encoding. */ static void unsuppress_quant_table (JPEGState* sp, int tblno) { JQUANT_TBL* qtbl; if ((qtbl = sp->cinfo.c.quant_tbl_ptrs[tblno]) != NULL) qtbl->sent_table = FALSE; } static void unsuppress_huff_table (JPEGState* sp, int tblno) { JHUFF_TBL* htbl; if ((htbl = sp->cinfo.c.dc_huff_tbl_ptrs[tblno]) != NULL) htbl->sent_table = FALSE; if ((htbl = sp->cinfo.c.ac_huff_tbl_ptrs[tblno]) != NULL) htbl->sent_table = FALSE; } static int prepare_JPEGTables(TIFF* tif) { JPEGState* sp = JState(tif); /* Initialize quant tables for current quality setting */ if (!TIFFjpeg_set_quality(sp, sp->jpegquality, FALSE)) return (0); /* Mark only the tables we want for output */ /* NB: chrominance tables are currently used only with YCbCr */ if (!TIFFjpeg_suppress_tables(sp, TRUE)) return (0); if (sp->jpegtablesmode & JPEGTABLESMODE_QUANT) { unsuppress_quant_table(sp, 0); if (sp->photometric == PHOTOMETRIC_YCBCR) unsuppress_quant_table(sp, 1); } if (sp->jpegtablesmode & JPEGTABLESMODE_HUFF) { unsuppress_huff_table(sp, 0); if (sp->photometric == PHOTOMETRIC_YCBCR) unsuppress_huff_table(sp, 1); } /* Direct libjpeg output into jpegtables */ if (!TIFFjpeg_tables_dest(sp, tif)) return (0); /* Emit tables-only datastream */ if (!TIFFjpeg_write_tables(sp)) return (0); return (1); } static int JPEGSetupEncode(TIFF* tif) { JPEGState* sp = JState(tif); TIFFDirectory *td = &tif->tif_dir; static const char module[] = "JPEGSetupEncode"; assert(sp != NULL); assert(!sp->cinfo.comm.is_decompressor); /* * Initialize all JPEG parameters to default values. * Note that jpeg_set_defaults needs legal values for * in_color_space and input_components. */ sp->cinfo.c.in_color_space = JCS_UNKNOWN; sp->cinfo.c.input_components = 1; if (!TIFFjpeg_set_defaults(sp)) return (0); /* Set per-file parameters */ sp->photometric = td->td_photometric; switch (sp->photometric) { case PHOTOMETRIC_YCBCR: sp->h_sampling = td->td_ycbcrsubsampling[0]; sp->v_sampling = td->td_ycbcrsubsampling[1]; /* * A ReferenceBlackWhite field *must* be present since the * default value is inappropriate for YCbCr. Fill in the * proper value if application didn't set it. */ #ifdef COLORIMETRY_SUPPORT if (!TIFFFieldSet(tif, FIELD_REFBLACKWHITE)) { float refbw[6]; long top = 1L << td->td_bitspersample; refbw[0] = 0; refbw[1] = (float)(top-1L); refbw[2] = (float)(top>>1); refbw[3] = refbw[1]; refbw[4] = refbw[2]; refbw[5] = refbw[1]; TIFFSetField(tif, TIFFTAG_REFERENCEBLACKWHITE, refbw); } #endif break; case PHOTOMETRIC_PALETTE: /* disallowed by Tech Note */ case PHOTOMETRIC_MASK: TIFFError(module, "PhotometricInterpretation %d not allowed for JPEG", (int) sp->photometric); return (0); default: /* TIFF 6.0 forbids subsampling of all other color spaces */ sp->h_sampling = 1; sp->v_sampling = 1; break; } /* Verify miscellaneous parameters */ /* * This would need work if libtiff ever supports different * depths for different components, or if libjpeg ever supports * run-time selection of depth. Neither is imminent. */ if (td->td_bitspersample != BITS_IN_JSAMPLE) { TIFFError(module, "BitsPerSample %d not allowed for JPEG", (int) td->td_bitspersample); return (0); } sp->cinfo.c.data_precision = td->td_bitspersample; if (isTiled(tif)) { if ((td->td_tilelength % (sp->v_sampling * DCTSIZE)) != 0) { TIFFError(module, "JPEG tile height must be multiple of %d", sp->v_sampling * DCTSIZE); return (0); } if ((td->td_tilewidth % (sp->h_sampling * DCTSIZE)) != 0) { TIFFError(module, "JPEG tile width must be multiple of %d", sp->h_sampling * DCTSIZE); return (0); } } else { if (td->td_rowsperstrip < td->td_imagelength && (td->td_rowsperstrip % (sp->v_sampling * DCTSIZE)) != 0) { TIFFError(module, "RowsPerStrip must be multiple of %d for JPEG", sp->v_sampling * DCTSIZE); return (0); } } /* Create a JPEGTables field if appropriate */ if (sp->jpegtablesmode & (JPEGTABLESMODE_QUANT|JPEGTABLESMODE_HUFF)) { if (!prepare_JPEGTables(tif)) return (0); /* Mark the field present */ /* Can't use TIFFSetField since BEENWRITING is already set! */ TIFFSetFieldBit(tif, FIELD_JPEGTABLES); tif->tif_flags |= TIFF_DIRTYDIRECT; } else { /* We do not support application-supplied JPEGTables, */ /* so mark the field not present */ TIFFClrFieldBit(tif, FIELD_JPEGTABLES); } /* Direct libjpeg output to libtiff's output buffer */ TIFFjpeg_data_dest(sp, tif); return (1); } /* * Set encoding state at the start of a strip or tile. */ static int JPEGPreEncode(TIFF* tif, tsample_t s) { JPEGState *sp = JState(tif); TIFFDirectory *td = &tif->tif_dir; static const char module[] = "JPEGPreEncode"; uint32 segment_width, segment_height; int downsampled_input; assert(sp != NULL); assert(!sp->cinfo.comm.is_decompressor); /* * Set encoding parameters for this strip/tile. */ if (isTiled(tif)) { segment_width = td->td_tilewidth; segment_height = td->td_tilelength; sp->bytesperline = TIFFTileRowSize(tif); } else { segment_width = td->td_imagewidth; segment_height = td->td_imagelength - tif->tif_row; if (segment_height > td->td_rowsperstrip) segment_height = td->td_rowsperstrip; sp->bytesperline = TIFFScanlineSize(tif); } if (td->td_planarconfig == PLANARCONFIG_SEPARATE && s > 0) { /* for PC 2, scale down the strip/tile size * to match a downsampled component */ segment_width = TIFFhowmany(segment_width, sp->h_sampling); segment_height = TIFFhowmany(segment_height, sp->v_sampling); } if (segment_width > 65535 || segment_height > 65535) { TIFFError(module, "Strip/tile too large for JPEG"); return (0); } sp->cinfo.c.image_width = segment_width; sp->cinfo.c.image_height = segment_height; downsampled_input = FALSE; if (td->td_planarconfig == PLANARCONFIG_CONTIG) { sp->cinfo.c.input_components = td->td_samplesperpixel; if (sp->photometric == PHOTOMETRIC_YCBCR) { if (sp->jpegcolormode == JPEGCOLORMODE_RGB) { sp->cinfo.c.in_color_space = JCS_RGB; } else { sp->cinfo.c.in_color_space = JCS_YCbCr; if (sp->h_sampling != 1 || sp->v_sampling != 1) downsampled_input = TRUE; } if (!TIFFjpeg_set_colorspace(sp, JCS_YCbCr)) return (0); /* * Set Y sampling factors; * we assume jpeg_set_colorspace() set the rest to 1 */ sp->cinfo.c.comp_info[0].h_samp_factor = sp->h_sampling; sp->cinfo.c.comp_info[0].v_samp_factor = sp->v_sampling; } else { sp->cinfo.c.in_color_space = JCS_UNKNOWN; if (!TIFFjpeg_set_colorspace(sp, JCS_UNKNOWN)) return (0); /* jpeg_set_colorspace set all sampling factors to 1 */ } } else { sp->cinfo.c.input_components = 1; sp->cinfo.c.in_color_space = JCS_UNKNOWN; if (!TIFFjpeg_set_colorspace(sp, JCS_UNKNOWN)) return (0); sp->cinfo.c.comp_info[0].component_id = s; /* jpeg_set_colorspace() set sampling factors to 1 */ if (sp->photometric == PHOTOMETRIC_YCBCR && s > 0) { sp->cinfo.c.comp_info[0].quant_tbl_no = 1; sp->cinfo.c.comp_info[0].dc_tbl_no = 1; sp->cinfo.c.comp_info[0].ac_tbl_no = 1; } } /* ensure libjpeg won't write any extraneous markers */ sp->cinfo.c.write_JFIF_header = FALSE; sp->cinfo.c.write_Adobe_marker = FALSE; /* set up table handling correctly */ if (! (sp->jpegtablesmode & JPEGTABLESMODE_QUANT)) { if (!TIFFjpeg_set_quality(sp, sp->jpegquality, FALSE)) return (0); unsuppress_quant_table(sp, 0); unsuppress_quant_table(sp, 1); } if (sp->jpegtablesmode & JPEGTABLESMODE_HUFF) sp->cinfo.c.optimize_coding = FALSE; else sp->cinfo.c.optimize_coding = TRUE; if (downsampled_input) { /* Need to use raw-data interface to libjpeg */ sp->cinfo.c.raw_data_in = TRUE; tif->tif_encoderow = JPEGEncodeRaw; tif->tif_encodestrip = JPEGEncodeRaw; tif->tif_encodetile = JPEGEncodeRaw; } else { /* Use normal interface to libjpeg */ sp->cinfo.c.raw_data_in = FALSE; tif->tif_encoderow = JPEGEncode; tif->tif_encodestrip = JPEGEncode; tif->tif_encodetile = JPEGEncode; } /* Start JPEG compressor */ if (!TIFFjpeg_start_compress(sp, FALSE)) return (0); /* Allocate downsampled-data buffers if needed */ if (downsampled_input) { if (!alloc_downsampled_buffers(tif, sp->cinfo.c.comp_info, sp->cinfo.c.num_components)) return (0); } sp->scancount = 0; return (1); } /* * Encode a chunk of pixels. * "Standard" case: incoming data is not downsampled. */ static int JPEGEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) { JPEGState *sp = JState(tif); tsize_t nrows; JSAMPROW bufptr[1]; (void) s; assert(sp != NULL); /* data is expected to be supplied in multiples of a scanline */ nrows = cc / sp->bytesperline; if (cc % sp->bytesperline) TIFFWarning(tif->tif_name, "fractional scanline discarded"); while (nrows-- > 0) { bufptr[0] = (JSAMPROW) buf; if (TIFFjpeg_write_scanlines(sp, bufptr, 1) != 1) return (0); if (nrows > 0) tif->tif_row++; buf += sp->bytesperline; } return (1); } /* * Encode a chunk of pixels. * Incoming data is expected to be downsampled per sampling factors. */ static int JPEGEncodeRaw(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) { JPEGState *sp = JState(tif); JSAMPLE* inptr; JSAMPLE* outptr; tsize_t nrows; JDIMENSION clumps_per_line, nclump; int clumpoffset, ci, xpos, ypos; jpeg_component_info* compptr; int samples_per_clump = sp->samplesperclump; (void) s; assert(sp != NULL); /* data is expected to be supplied in multiples of a scanline */ nrows = cc / sp->bytesperline; if (cc % sp->bytesperline) TIFFWarning(tif->tif_name, "fractional scanline discarded"); /* Cb,Cr both have sampling factors 1, so this is correct */ clumps_per_line = sp->cinfo.c.comp_info[1].downsampled_width; while (nrows-- > 0) { /* * Fastest way to separate the data is to make one pass * over the scanline for each row of each component. */ clumpoffset = 0; /* first sample in clump */ for (ci = 0, compptr = sp->cinfo.c.comp_info; ci < sp->cinfo.c.num_components; ci++, compptr++) { int hsamp = compptr->h_samp_factor; int vsamp = compptr->v_samp_factor; int padding = (int) (compptr->width_in_blocks * DCTSIZE - clumps_per_line * hsamp); for (ypos = 0; ypos < vsamp; ypos++) { inptr = ((JSAMPLE*) buf) + clumpoffset; outptr = sp->ds_buffer[ci][sp->scancount*vsamp + ypos]; if (hsamp == 1) { /* fast path for at least Cb and Cr */ for (nclump = clumps_per_line; nclump-- > 0; ) { *outptr++ = inptr[0]; inptr += samples_per_clump; } } else { /* general case */ for (nclump = clumps_per_line; nclump-- > 0; ) { for (xpos = 0; xpos < hsamp; xpos++) *outptr++ = inptr[xpos]; inptr += samples_per_clump; } } /* pad each scanline as needed */ for (xpos = 0; xpos < padding; xpos++) { *outptr = outptr[-1]; outptr++; } clumpoffset += hsamp; } } sp->scancount++; if (sp->scancount >= DCTSIZE) { int n = sp->cinfo.c.max_v_samp_factor * DCTSIZE; if (TIFFjpeg_write_raw_data(sp, sp->ds_buffer, n) != n) return (0); sp->scancount = 0; } if (nrows > 0) tif->tif_row++; buf += sp->bytesperline; } return (1); } /* * Finish up at the end of a strip or tile. */ static int JPEGPostEncode(TIFF* tif) { JPEGState *sp = JState(tif); if (sp->scancount > 0) { /* * Need to emit a partial bufferload of downsampled data. * Pad the data vertically. */ int ci, ypos, n; jpeg_component_info* compptr; for (ci = 0, compptr = sp->cinfo.c.comp_info; ci < sp->cinfo.c.num_components; ci++, compptr++) { int vsamp = compptr->v_samp_factor; tsize_t row_width = compptr->width_in_blocks * DCTSIZE * sizeof(JSAMPLE); for (ypos = sp->scancount * vsamp; ypos < DCTSIZE * vsamp; ypos++) { _TIFFmemcpy((tdata_t)sp->ds_buffer[ci][ypos], (tdata_t)sp->ds_buffer[ci][ypos-1], row_width); } } n = sp->cinfo.c.max_v_samp_factor * DCTSIZE; if (TIFFjpeg_write_raw_data(sp, sp->ds_buffer, n) != n) return (0); } return (TIFFjpeg_finish_compress(JState(tif))); } static void JPEGCleanup(TIFF* tif) { if (tif->tif_data) { JPEGState *sp = JState(tif); TIFFjpeg_destroy(sp); /* release libjpeg resources */ if (sp->jpegtables) /* tag value */ _TIFFfree(sp->jpegtables); _TIFFfree(tif->tif_data); /* release local state */ tif->tif_data = NULL; } } static int JPEGVSetField(TIFF* tif, ttag_t tag, va_list ap) { JPEGState* sp = JState(tif); TIFFDirectory* td = &tif->tif_dir; uint32 v32; switch (tag) { case TIFFTAG_JPEGTABLES: v32 = va_arg(ap, uint32); if (v32 == 0) { /* XXX */ return (0); } _TIFFsetByteArray(&sp->jpegtables, va_arg(ap, void*), (long) v32); sp->jpegtables_length = v32; TIFFSetFieldBit(tif, FIELD_JPEGTABLES); break; case TIFFTAG_JPEGQUALITY: sp->jpegquality = va_arg(ap, int); return (1); /* pseudo tag */ case TIFFTAG_JPEGCOLORMODE: sp->jpegcolormode = va_arg(ap, int); /* * Mark whether returned data is up-sampled or not * so TIFFStripSize and TIFFTileSize return values * that reflect the true amount of data. */ tif->tif_flags &= ~TIFF_UPSAMPLED; if (td->td_planarconfig == PLANARCONFIG_CONTIG) { if (td->td_photometric == PHOTOMETRIC_YCBCR && sp->jpegcolormode == JPEGCOLORMODE_RGB) { tif->tif_flags |= TIFF_UPSAMPLED; } else { if (td->td_ycbcrsubsampling[0] != 1 || td->td_ycbcrsubsampling[1] != 1) ; /* XXX what about up-sampling? */ } } /* * Must recalculate cached tile size * in case sampling state changed. */ tif->tif_tilesize = TIFFTileSize(tif); return (1); /* pseudo tag */ case TIFFTAG_JPEGTABLESMODE: sp->jpegtablesmode = va_arg(ap, int); return (1); /* pseudo tag */ default: return (*sp->vsetparent)(tif, tag, ap); } tif->tif_flags |= TIFF_DIRTYDIRECT; return (1); } static int JPEGVGetField(TIFF* tif, ttag_t tag, va_list ap) { JPEGState* sp = JState(tif); switch (tag) { case TIFFTAG_JPEGTABLES: /* u_short is bogus --- should be uint32 ??? */ /* TIFFWriteNormalTag needs fixed XXX */ *va_arg(ap, u_short*) = (u_short) sp->jpegtables_length; *va_arg(ap, void**) = sp->jpegtables; break; case TIFFTAG_JPEGQUALITY: *va_arg(ap, int*) = sp->jpegquality; break; case TIFFTAG_JPEGCOLORMODE: *va_arg(ap, int*) = sp->jpegcolormode; break; case TIFFTAG_JPEGTABLESMODE: *va_arg(ap, int*) = sp->jpegtablesmode; break; default: return (*sp->vgetparent)(tif, tag, ap); } return (1); } static void JPEGPrintDir(TIFF* tif, FILE* fd, long flags) { JPEGState* sp = JState(tif); (void) flags; if (TIFFFieldSet(tif,FIELD_JPEGTABLES)) fprintf(fd, " JPEG Tables: (%lu bytes)\n", (u_long) sp->jpegtables_length); } static uint32 JPEGDefaultStripSize(TIFF* tif, uint32 s) { JPEGState* sp = JState(tif); TIFFDirectory *td = &tif->tif_dir; s = (*sp->defsparent)(tif, s); if (s < td->td_imagelength) s = TIFFroundup(s, td->td_ycbcrsubsampling[1] * DCTSIZE); return (s); } static void JPEGDefaultTileSize(TIFF* tif, uint32* tw, uint32* th) { JPEGState* sp = JState(tif); TIFFDirectory *td = &tif->tif_dir; (*sp->deftparent)(tif, tw, th); *tw = TIFFroundup(*tw, td->td_ycbcrsubsampling[0] * DCTSIZE); *th = TIFFroundup(*th, td->td_ycbcrsubsampling[1] * DCTSIZE); } int TIFFInitJPEG(TIFF* tif, int scheme) { JPEGState* sp; assert(scheme == COMPRESSION_JPEG); /* * Allocate state block so tag methods have storage to record values. */ tif->tif_data = (tidata_t) _TIFFmalloc(sizeof (JPEGState)); if (tif->tif_data == NULL) { TIFFError("TIFFInitJPEG", "No space for JPEG state block"); return (0); } sp = JState(tif); sp->tif = tif; /* back link */ /* * Merge codec-specific tag information and * override parent get/set field methods. */ _TIFFMergeFieldInfo(tif, jpegFieldInfo, N(jpegFieldInfo)); sp->vgetparent = tif->tif_vgetfield; tif->tif_vgetfield = JPEGVGetField; /* hook for codec tags */ sp->vsetparent = tif->tif_vsetfield; tif->tif_vsetfield = JPEGVSetField; /* hook for codec tags */ tif->tif_printdir = JPEGPrintDir; /* hook for codec tags */ /* Default values for codec-specific fields */ sp->jpegtables = NULL; sp->jpegtables_length = 0; sp->jpegquality = 75; /* Default IJG quality */ sp->jpegcolormode = JPEGCOLORMODE_RAW; sp->jpegtablesmode = JPEGTABLESMODE_QUANT | JPEGTABLESMODE_HUFF; /* * Install codec methods. */ tif->tif_setupdecode = JPEGSetupDecode; tif->tif_predecode = JPEGPreDecode; tif->tif_decoderow = JPEGDecode; tif->tif_decodestrip = JPEGDecode; tif->tif_decodetile = JPEGDecode; tif->tif_setupencode = JPEGSetupEncode; tif->tif_preencode = JPEGPreEncode; tif->tif_postencode = JPEGPostEncode; tif->tif_encoderow = JPEGEncode; tif->tif_encodestrip = JPEGEncode; tif->tif_encodetile = JPEGEncode; tif->tif_cleanup = JPEGCleanup; sp->defsparent = tif->tif_defstripsize; tif->tif_defstripsize = JPEGDefaultStripSize; sp->deftparent = tif->tif_deftilesize; tif->tif_deftilesize = JPEGDefaultTileSize; tif->tif_flags |= TIFF_NOBITREV; /* no bit reversal, please */ /* * Initialize libjpeg. */ if (tif->tif_mode == O_RDONLY) { if (!TIFFjpeg_create_decompress(sp)) return (0); } else { if (!TIFFjpeg_create_compress(sp)) return (0); } return (1); } #endif /* JPEG_SUPPORT */ netpbm-8.2/libtiff/tif_luv.c0100660000076400000000000010375107020035370015124 0ustar bryanhroot/* * Copyright (c) 1997 Greg Ward Larson * Copyright (c) 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, Greg Larson 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, Greg Larson 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, GREG LARSON 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. */ #include "tiffiop.h" #ifdef LOGLUV_SUPPORT /* * TIFF Library. * LogLuv compression support for high dynamic range images. * * Contributed by Greg Larson. * * LogLuv image support uses the TIFF library to store 16 or 10-bit * log luminance values with 8 bits each of u and v or a 14-bit index. * * The codec can take as input and produce as output 32-bit IEEE float values * as well as 16-bit integer values. A 16-bit luminance is interpreted * as a sign bit followed by a 15-bit integer that is converted * to and from a linear magnitude using the transformation: * * L = 2^( (Le+.5)/256 - 64 ) # real from 15-bit * * Le = floor( 256*(log2(L) + 64) ) # 15-bit from real * * The actual conversion to world luminance units in candelas per sq. meter * requires an additional multiplier, which is stored in the TIFFTAG_STONITS. * This value is usually set such that a reasonable exposure comes from * clamping decoded luminances above 1 to 1 in the displayed image. * * The 16-bit values for u and v may be converted to real values by dividing * each by 32768. (This allows for negative values, which aren't useful as * far as we know, but are left in case of future improvements in human * color vision.) * * Conversion from (u,v), which is actually the CIE (u',v') system for * you color scientists, is accomplished by the following transformation: * * u = 4*x / (-2*x + 12*y + 3) * v = 9*y / (-2*x + 12*y + 3) * * x = 9*u / (6*u - 16*v + 12) * y = 4*v / (6*u - 16*v + 12) * * This process is greatly simplified by passing 32-bit IEEE floats * for each of three CIE XYZ coordinates. The codec then takes care * of conversion to and from LogLuv, though the application is still * responsible for interpreting the TIFFTAG_STONITS calibration factor. * * The information is compressed into one of two basic encodings, depending on * the setting of the compression tag, which is one of COMPRESSION_SGILOG * or COMPRESSION_SGILOG24. For COMPRESSION_SGILOG, greyscale data is * stored as: * * 1 15 * |-+---------------| * * COMPRESSION_SGILOG color data is stored as: * * 1 15 8 8 * |-+---------------|--------+--------| * S Le ue ve * * For the 24-bit COMPRESSION_SGILOG24 color format, the data is stored as: * * 10 14 * |----------|--------------| * Le' Ce * * There is no sign bit in the 24-bit case, and the (u,v) chromaticity is * encoded as an index for optimal color resolution. The 10 log bits are * defined by the following conversions: * * L = 2^((Le'+.5)/64 - 12) # real from 10-bit * * Le' = floor( 64*(log2(L) + 12) ) # 10-bit from real * * The 10 bits of the smaller format may be converted into the 15 bits of * the larger format by multiplying by 4 and adding 13314. Obviously, * a smaller range of magnitudes is covered (about 5 orders of magnitude * instead of 38), and the lack of a sign bit means that negative luminances * are not allowed. (Well, they aren't allowed in the real world, either, * but they are useful for certain types of image processing.) * * The desired user format is controlled by the setting the internal * pseudo tag TIFFTAG_SGILOGDATAFMT to one of: * SGILOGDATAFMT_FLOAT = IEEE 32-bit float XYZ values * SGILOGDATAFMT_16BIT = 16-bit integer encodings of logL, u and v * Raw data i/o is also possible using: * SGILOGDATAFMT_RAW = 32-bit unsigned integer with encoded pixel * In addition, the following decoding is provided for ease of display: * SGILOGDATAFMT_8BIT = 8-bit default RGB gamma-corrected values * * For grayscale images, we provide the following data formats: * SGILOGDATAFMT_FLOAT = IEEE 32-bit float Y values * SGILOGDATAFMT_16BIT = 16-bit integer w/ encoded luminance * SGILOGDATAFMT_8BIT = 8-bit gray monitor values * * Note that the COMPRESSION_SGILOG applies a simple run-length encoding * scheme by separating the logL, u and v bytes for each row and applying * a PackBits type of compression. Since the 24-bit encoding is not * adaptive, the 32-bit color format takes less space in many cases. */ #include #include #include #include /* * State block for each open TIFF * file using LogLuv compression/decompression. */ typedef struct logLuvState LogLuvState; struct logLuvState { int user_datafmt; /* user data format */ int pixel_size; /* bytes per pixel */ tidata_t* tbuf; /* translation buffer */ short tbuflen; /* buffer length */ void (*tfunc)(LogLuvState*, tidata_t, int); TIFFVSetMethod vgetparent; /* super-class method */ TIFFVSetMethod vsetparent; /* super-class method */ }; #define DecoderState(tif) ((LogLuvState*) (tif)->tif_data) #define EncoderState(tif) ((LogLuvState*) (tif)->tif_data) #define N(a) (sizeof(a)/sizeof(a[0])) #define SGILOGDATAFMT_UNKNOWN -1 #define MINRUN 4 /* minimum run length */ /* * Decode a string of 16-bit gray pixels. */ static int LogL16Decode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) { LogLuvState* sp = DecoderState(tif); int shft, i, npixels; u_char* bp; int16* tp; int16 b; int cc, rc; assert(s == 0); assert(sp != NULL); npixels = occ / sp->pixel_size; if (sp->user_datafmt == SGILOGDATAFMT_16BIT) tp = (int16*) op; else { assert(sp->tbuflen >= npixels); tp = (int16*) sp->tbuf; } _TIFFmemset((tdata_t) tp, 0, npixels*sizeof (tp[0])); bp = (u_char*) tif->tif_rawcp; cc = tif->tif_rawcc; /* get each byte string */ for (shft = 2*8; (shft -= 8) >= 0; ) { for (i = 0; i < npixels && cc > 0; ) if (*bp >= 128) { /* run */ rc = *bp++ + (2-128); b = (int16)*bp++ << shft; cc -= 2; while (rc--) tp[i++] |= b; } else { /* non-run */ rc = *bp++; /* nul is noop */ while (--cc && rc--) tp[i++] |= (int16)*bp++ << shft; } if (i != npixels) { TIFFError(tif->tif_name, "LogL16Decode: Not enough data at row %d (short %d pixels)", tif->tif_row, npixels - i); tif->tif_rawcp = (tidata_t) bp; tif->tif_rawcc = cc; return (0); } } (*sp->tfunc)(sp, op, npixels); tif->tif_rawcp = (tidata_t) bp; tif->tif_rawcc = cc; return (1); } /* * Decode a string of 24-bit pixels. */ static int LogLuvDecode24(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) { LogLuvState* sp = DecoderState(tif); int cc, i, npixels; u_char* bp; uint32* tp; assert(s == 0); assert(sp != NULL); npixels = occ / sp->pixel_size; if (sp->user_datafmt == SGILOGDATAFMT_RAW) tp = (uint32 *)op; else { assert(sp->tbuflen >= npixels); tp = (uint32 *) sp->tbuf; } _TIFFmemset((tdata_t) tp, 0, npixels*sizeof (tp[0])); /* copy to array of uint32 */ bp = (u_char*) tif->tif_rawcp; cc = tif->tif_rawcc; for (i = 0; i < npixels && cc > 0; i++) { tp[i] = bp[0] << 16 | bp[1] << 8 | bp[2]; bp += 3; cc -= 3; } tif->tif_rawcp = (tidata_t) bp; tif->tif_rawcc = cc; if (i != npixels) { TIFFError(tif->tif_name, "LogLuvDecode24: Not enough data at row %d (short %d pixels)", tif->tif_row, npixels - i); return (0); } (*sp->tfunc)(sp, op, npixels); return (1); } /* * Decode a string of 32-bit pixels. */ static int LogLuvDecode32(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) { LogLuvState* sp; int shft, i, npixels; u_char* bp; uint32* tp; uint32 b; int cc, rc; assert(s == 0); sp = DecoderState(tif); assert(sp != NULL); npixels = occ / sp->pixel_size; if (sp->user_datafmt == SGILOGDATAFMT_RAW) tp = (uint32*) op; else { assert(sp->tbuflen >= npixels); tp = (uint32*) sp->tbuf; } _TIFFmemset((tdata_t) tp, 0, npixels*sizeof (tp[0])); bp = (u_char*) tif->tif_rawcp; cc = tif->tif_rawcc; /* get each byte string */ for (shft = 4*8; (shft -= 8) >= 0; ) { for (i = 0; i < npixels && cc > 0; ) if (*bp >= 128) { /* run */ rc = *bp++ + (2-128); b = (uint32)*bp++ << shft; cc -= 2; while (rc--) tp[i++] |= b; } else { /* non-run */ rc = *bp++; /* nul is noop */ while (--cc && rc--) tp[i++] |= (uint32)*bp++ << shft; } if (i != npixels) { TIFFError(tif->tif_name, "LogLuvDecode32: Not enough data at row %d (short %d pixels)", tif->tif_row, npixels - i); tif->tif_rawcp = (tidata_t) bp; tif->tif_rawcc = cc; return (0); } } (*sp->tfunc)(sp, op, npixels); tif->tif_rawcp = (tidata_t) bp; tif->tif_rawcc = cc; return (1); } /* * Decode a strip of pixels. We break it into rows to * maintain synchrony with the encode algorithm, which * is row by row. */ static int LogLuvDecodeStrip(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) { tsize_t rowlen = TIFFScanlineSize(tif); assert(cc%rowlen == 0); while (cc && (*tif->tif_decoderow)(tif, bp, rowlen, s)) bp += rowlen, cc -= rowlen; return (cc == 0); } /* * Decode a tile of pixels. We break it into rows to * maintain synchrony with the encode algorithm, which * is row by row. */ static int LogLuvDecodeTile(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) { tsize_t rowlen = TIFFTileRowSize(tif); assert(cc%rowlen == 0); while (cc && (*tif->tif_decoderow)(tif, bp, rowlen, s)) bp += rowlen, cc -= rowlen; return (cc == 0); } /* * Encode a row of 16-bit pixels. */ static int LogL16Encode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) { LogLuvState* sp = EncoderState(tif); int shft, i, j, npixels; tidata_t op; int16* tp; int16 b; int occ, rc=0, mask, beg; assert(s == 0); assert(sp != NULL); npixels = cc / sp->pixel_size; if (sp->user_datafmt == SGILOGDATAFMT_16BIT) tp = (int16*) bp; else { tp = (int16*) sp->tbuf; assert(sp->tbuflen >= npixels); (*sp->tfunc)(sp, bp, npixels); } /* compress each byte string */ op = tif->tif_rawcp; occ = tif->tif_rawdatasize - tif->tif_rawcc; for (shft = 2*8; (shft -= 8) >= 0; ) for (i = 0; i < npixels; i += rc) { if (occ < 4) { tif->tif_rawcp = op; tif->tif_rawcc = tif->tif_rawdatasize - occ; if (!TIFFFlushData1(tif)) return (-1); op = tif->tif_rawcp; occ = tif->tif_rawdatasize - tif->tif_rawcc; } mask = 0xff << shft; /* find next run */ for (beg = i; beg < npixels; beg += rc) { b = tp[beg] & mask; rc = 1; while (rc < 127+2 && beg+rc < npixels && (tp[beg+rc] & mask) == b) rc++; if (rc >= MINRUN) break; /* long enough */ } if (beg-i > 1 && beg-i < MINRUN) { b = tp[i] & mask; /* check short run */ j = i+1; while ((tp[j++] & mask) == b) if (j == beg) { *op++ = 128-2+j-i; *op++ = b >> shft; occ -= 2; i = beg; break; } } while (i < beg) { /* write out non-run */ if ((j = beg-i) > 127) j = 127; if (occ < j+3) { tif->tif_rawcp = op; tif->tif_rawcc = tif->tif_rawdatasize - occ; if (!TIFFFlushData1(tif)) return (-1); op = tif->tif_rawcp; occ = tif->tif_rawdatasize - tif->tif_rawcc; } *op++ = j; occ--; while (j--) { *op++ = tp[i++] >> shft & 0xff; occ--; } } if (rc >= MINRUN) { /* write out run */ *op++ = 128-2+rc; *op++ = tp[beg] >> shft & 0xff; occ -= 2; } else rc = 0; } tif->tif_rawcp = op; tif->tif_rawcc = tif->tif_rawdatasize - occ; return (0); } /* * Encode a row of 24-bit pixels. */ static int LogLuvEncode24(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) { LogLuvState* sp = EncoderState(tif); int i, npixels, occ; tidata_t op; uint32* tp; assert(s == 0); assert(sp != NULL); npixels = cc / sp->pixel_size; if (sp->user_datafmt == SGILOGDATAFMT_RAW) tp = (uint32*) bp; else { tp = (uint32*) sp->tbuf; assert(sp->tbuflen >= npixels); (*sp->tfunc)(sp, bp, npixels); } /* write out encoded pixels */ op = tif->tif_rawcp; occ = tif->tif_rawdatasize - tif->tif_rawcc; for (i = npixels; i--; ) { if (occ < 3) { tif->tif_rawcp = op; tif->tif_rawcc = tif->tif_rawdatasize - occ; if (!TIFFFlushData1(tif)) return (-1); op = tif->tif_rawcp; occ = tif->tif_rawdatasize - tif->tif_rawcc; } *op++ = (tidataval_t)(*tp >> 16); *op++ = (tidataval_t)(*tp >> 8 & 0xff); *op++ = (tidataval_t)(*tp++ & 0xff); occ -= 3; } tif->tif_rawcp = op; tif->tif_rawcc = tif->tif_rawdatasize - occ; return (0); } /* * Encode a row of 32-bit pixels. */ static int LogLuvEncode32(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) { LogLuvState* sp = EncoderState(tif); int shft, i, j, npixels; tidata_t op; uint32* tp; uint32 b; int occ, rc=0, mask, beg; assert(s == 0); assert(sp != NULL); npixels = cc / sp->pixel_size; if (sp->user_datafmt == SGILOGDATAFMT_RAW) tp = (uint32*) bp; else { tp = (uint32*) sp->tbuf; assert(sp->tbuflen >= npixels); (*sp->tfunc)(sp, bp, npixels); } /* compress each byte string */ op = tif->tif_rawcp; occ = tif->tif_rawdatasize - tif->tif_rawcc; for (shft = 4*8; (shft -= 8) >= 0; ) for (i = 0; i < npixels; i += rc) { if (occ < 4) { tif->tif_rawcp = op; tif->tif_rawcc = tif->tif_rawdatasize - occ; if (!TIFFFlushData1(tif)) return (-1); op = tif->tif_rawcp; occ = tif->tif_rawdatasize - tif->tif_rawcc; } mask = 0xff << shft; /* find next run */ for (beg = i; beg < npixels; beg += rc) { b = tp[beg] & mask; rc = 1; while (rc < 127+2 && beg+rc < npixels && (tp[beg+rc] & mask) == b) rc++; if (rc >= MINRUN) break; /* long enough */ } if (beg-i > 1 && beg-i < MINRUN) { b = tp[i] & mask; /* check short run */ j = i+1; while ((tp[j++] & mask) == b) if (j == beg) { *op++ = (tidataval_t)(128-2+j-i); *op++ = (tidataval_t)(b >> shft); occ -= 2; i = beg; break; } } while (i < beg) { /* write out non-run */ if ((j = beg-i) > 127) j = 127; if (occ < j+3) { tif->tif_rawcp = op; tif->tif_rawcc = tif->tif_rawdatasize - occ; if (!TIFFFlushData1(tif)) return (-1); op = tif->tif_rawcp; occ = tif->tif_rawdatasize - tif->tif_rawcc; } *op++ = j; occ--; while (j--) { *op++ = (tidataval_t)(tp[i++] >> shft & 0xff); occ--; } } if (rc >= MINRUN) { /* write out run */ *op++ = 128-2+rc; *op++ = (tidataval_t)(tp[beg] >> shft & 0xff); occ -= 2; } else rc = 0; } tif->tif_rawcp = op; tif->tif_rawcc = tif->tif_rawdatasize - occ; return (0); } /* * Encode a strip of pixels. We break it into rows to * avoid encoding runs across row boundaries. */ static int LogLuvEncodeStrip(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) { tsize_t rowlen = TIFFScanlineSize(tif); assert(cc%rowlen == 0); while (cc && (*tif->tif_encoderow)(tif, bp, rowlen, s) == 0) bp += rowlen, cc -= rowlen; return (cc == 0); } /* * Encode a tile of pixels. We break it into rows to * avoid encoding runs across row boundaries. */ static int LogLuvEncodeTile(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) { tsize_t rowlen = TIFFTileRowSize(tif); assert(cc%rowlen == 0); while (cc && (*tif->tif_encoderow)(tif, bp, rowlen, s) == 0) bp += rowlen, cc -= rowlen; return (cc == 0); } /* * Encode/Decode functions for converting to and from user formats. */ #include "uvcode.h" #define U_NEU 0.210526316 #define V_NEU 0.473684211 #ifdef M_LN2 #define LOGOF2 M_LN2 #else #define LOGOF2 0.69314718055994530942 #endif #define log2(x) ((1./LOGOF2)*log(x)) #define exp2(x) exp(LOGOF2*(x)) #define UVSCALE 410. static double pix16toY(int p16) { int Le = p16 & 0x7fff; double Y; if (!Le) return (0.); Y = exp(LOGOF2/256.*(Le+.5) - LOGOF2*64.); if (p16 & 0x8000) return (-Y); return (Y); } static int pix16fromY(double Y) { if (Y >= 1.84467e19) return (0x7fff); if (Y <= -1.84467e19) return (0xffff); if (Y > 5.43571e-20) return (int)(256.*(log2(Y) + 64.)); if (Y < -5.43571e-20) return (~0x7fff | (int)(256.*(log2(-Y) + 64.))); return (0); } static void L16toY(LogLuvState* sp, tidata_t op, int n) { int16* l16 = (int16*) sp->tbuf; float* yp = (float*) op; while (n-- > 0) *yp++ = (float)pix16toY(*l16++); } static void L16toGry(LogLuvState* sp, tidata_t op, int n) { int16* l16 = (int16*) sp->tbuf; uint8* gp = (uint8*) op; while (n-- > 0) { double Y = pix16toY(*l16++); *gp++ = (Y <= 0.) ? 0 : (Y >= 1.) ? 255 : (int)(256.*sqrt(Y)); } } static void L16fromY(LogLuvState* sp, tidata_t op, int n) { int16* l16 = (int16*) sp->tbuf; float* yp = (float*) op; while (n-- > 0) *l16++ = pix16fromY(*yp++); } static void XYZtoRGB24(float xyz[3], uint8 rgb[3]) { double r, g, b; /* assume CCIR-709 primaries */ r = 2.690*xyz[0] + -1.276*xyz[1] + -0.414*xyz[2]; g = -1.022*xyz[0] + 1.978*xyz[1] + 0.044*xyz[2]; b = 0.061*xyz[0] + -0.224*xyz[1] + 1.163*xyz[2]; /* assume 2.0 gamma for speed */ /* could use integer sqrt approx., but this is probably faster */ rgb[0] = (r <= 0.) ? 0 : (r >= 1.) ? 255 : (int)(256.*sqrt(r)); rgb[1] = (g <= 0.) ? 0 : (g >= 1.) ? 255 : (int)(256.*sqrt(g)); rgb[2] = (b <= 0.) ? 0 : (b >= 1.) ? 255 : (int)(256.*sqrt(b)); } static int uv_encode(double u, double v) /* encode (u',v') coordinates */ { register int vi, ui; if (v < UV_VSTART) return(-1); vi = (int)((v - UV_VSTART)*(1./UV_SQSIZ)); if (vi >= UV_NVS) return(-1); if (u < uv_row[vi].ustart) return(-1); ui = (int)((u - uv_row[vi].ustart)*(1./UV_SQSIZ)); if (ui >= uv_row[vi].nus) return(-1); return(uv_row[vi].ncum + ui); } static int uv_decode(double *up, double *vp, int c) /* decode (u',v') index */ { int upper, lower; register int ui, vi; if (c < 0 || c >= UV_NDIVS) return(-1); lower = 0; /* binary search */ upper = UV_NVS; do { vi = (lower + upper) >> 1; ui = c - uv_row[vi].ncum; if (ui > 0) lower = vi; else if (ui < 0) upper = vi; else break; } while (upper - lower > 1); vi = lower; ui = c - uv_row[vi].ncum; *up = uv_row[vi].ustart + (ui+.5)*UV_SQSIZ; *vp = UV_VSTART + (vi+.5)*UV_SQSIZ; return(0); } static void pix24toXYZ(uint32 p, float XYZ[3]) { int Le, Ce; double L, u, v, s, x, y; /* decode luminance */ Le = p >> 14 & 0x3ff; if (Le == 0) { XYZ[0] = XYZ[1] = XYZ[2] = 0.; return; } L = exp(LOGOF2/64.*(Le+.5) - LOGOF2*12.); /* decode color */ Ce = p & 0x3fff; if (uv_decode(&u, &v, Ce) < 0) { u = U_NEU; v = V_NEU; } s = 1./(6.*u - 16.*v + 12.); x = 9.*u * s; y = 4.*v * s; /* convert to XYZ */ XYZ[0] = (float)(x/y * L); XYZ[1] = (float)L; XYZ[2] = (float)((1.-x-y)/y * L); } static uint32 pix24fromXYZ(float XYZ[3]) { int Le, Ce; double L, u, v, s; /* encode luminance */ L = XYZ[1]; if (L >= 16.) Le = 0x3ff; else if (L <= 1./4096.) Le = 0; else Le = (int)(64.*(log2(L) + 12.)); /* encode color */ s = XYZ[0] + 15.*XYZ[1] + 3.*XYZ[2]; if (s == 0.) { u = U_NEU; v = V_NEU; } else { u = 4.*XYZ[0] / s; v = 9.*XYZ[1] / s; } Ce = uv_encode(u, v); if (Ce < 0) Ce = uv_encode(U_NEU, V_NEU); /* combine encodings */ return (Le << 14 | Ce); } static void Luv24toXYZ(LogLuvState* sp, tidata_t op, int n) { uint32* luv = (uint32*) sp->tbuf; float* xyz = (float*) op; while (n-- > 0) { pix24toXYZ(*luv, xyz); xyz += 3; luv++; } } static void Luv24toLuv48(LogLuvState* sp, tidata_t op, int n) { uint32* luv = (uint32*) sp->tbuf; int16* luv3 = (int16*) op; while (n-- > 0) { double u, v; *luv3++ = (int16)((*luv >> 12 & 0xffd) + 13314); if (uv_decode(&u, &v, *luv&0x3fff) < 0) { u = U_NEU; v = V_NEU; } *luv3++ = (int16)(u * (1L<<15)); *luv3++ = (int16)(v * (1L<<15)); luv++; } } static void Luv24toRGB(LogLuvState* sp, tidata_t op, int n) { uint32* luv = (uint32*) sp->tbuf; uint8* rgb = (uint8*) op; while (n-- > 0) { float xyz[3]; pix24toXYZ(*luv++, xyz); XYZtoRGB24(xyz, rgb); rgb += 3; } } static void Luv24fromXYZ(LogLuvState* sp, tidata_t op, int n) { uint32* luv = (uint32*) sp->tbuf; float* xyz = (float*) op; while (n-- > 0) { *luv++ = pix24fromXYZ(xyz); xyz += 3; } } static void Luv24fromLuv48(LogLuvState* sp, tidata_t op, int n) { uint32* luv = (uint32*) sp->tbuf; int16* luv3 = (int16*) op; while (n-- > 0) { int Le, Ce; if (luv3[0] <= 0) Le = 0; else if (luv3[0] >= (1<<12)+3314) Le = (1<<10) - 1; else Le = (luv3[0]-3314) >> 2; Ce = uv_encode((luv[1]+.5)/(1<<15), (luv[2]+.5)/(1<<15)); if (Ce < 0) Ce = uv_encode(U_NEU, V_NEU); *luv++ = (uint32)Le << 14 | Ce; luv3 += 3; } } static void pix32toXYZ(uint32 p, float XYZ[3]) { double L, u, v, s, x, y; /* decode luminance */ L = pix16toY((int)p >> 16); if (L == 0.) { XYZ[0] = XYZ[1] = XYZ[2] = 0.; return; } /* decode color */ u = 1./UVSCALE * ((p>>8 & 0xff) + .5); v = 1./UVSCALE * ((p & 0xff) + .5); s = 1./(6.*u - 16.*v + 12.); x = 9.*u * s; y = 4.*v * s; /* convert to XYZ */ XYZ[0] = (float)(x/y * L); XYZ[1] = (float)L; XYZ[2] = (float)((1.-x-y)/y * L); } static uint32 pix32fromXYZ(float XYZ[3]) { unsigned int Le, ue, ve; double u, v, s; /* encode luminance */ Le = (unsigned int)pix16fromY(XYZ[1]); /* encode color */ s = XYZ[0] + 15.*XYZ[1] + 3.*XYZ[2]; if (s == 0.) { u = U_NEU; v = V_NEU; } else { u = 4.*XYZ[0] / s; v = 9.*XYZ[1] / s; } if (u <= 0.) ue = 0; else ue = (unsigned int)(UVSCALE * u); if (ue > 255) ue = 255; if (v <= 0.) ve = 0; else ve = (unsigned int)(UVSCALE * v); if (ve > 255) ve = 255; /* combine encodings */ return (Le << 16 | ue << 8 | ve); } static void Luv32toXYZ(LogLuvState* sp, tidata_t op, int n) { uint32* luv = (uint32*) sp->tbuf; float* xyz = (float*) op; while (n-- > 0) { pix32toXYZ(*luv++, xyz); xyz += 3; } } static void Luv32toLuv48(LogLuvState* sp, tidata_t op, int n) { uint32* luv = (uint32*) sp->tbuf; int16* luv3 = (int16*) op; while (n-- > 0) { double u, v; *luv3++ = (int16)(*luv >> 16); u = 1./UVSCALE * ((*luv>>8 & 0xff) + .5); v = 1./UVSCALE * ((*luv & 0xff) + .5); *luv3++ = (int16)(u * (1L<<15)); *luv3++ = (int16)(v * (1L<<15)); luv++; } } static void Luv32toRGB(LogLuvState* sp, tidata_t op, int n) { uint32* luv = (uint32*) sp->tbuf; uint8* rgb = (uint8*) op; while (n-- > 0) { float xyz[3]; pix32toXYZ(*luv++, xyz); XYZtoRGB24(xyz, rgb); rgb += 3; } } static void Luv32fromXYZ(LogLuvState* sp, tidata_t op, int n) { uint32* luv = (uint32*) sp->tbuf; float* xyz = (float*) op; while (n-- > 0) { *luv++ = pix32fromXYZ(xyz); xyz += 3; } } static void Luv32fromLuv48(LogLuvState* sp, tidata_t op, int n) { uint32* luv = (uint32*) sp->tbuf; int16* luv3 = (int16*) op; while (n-- > 0) { *luv++ = (uint32)luv3[0] << 16 | (luv3[1]*(uint32)(UVSCALE+.5) >> 7 & 0xff00) | (luv3[2]*(uint32)(UVSCALE+.5) >> 15 & 0xff); luv3 += 3; } } static void _logLuvNop(LogLuvState* sp, tidata_t op, int n) { (void) sp; (void) op; (void) n; } static int LogL16GuessDataFmt(TIFFDirectory *td) { #define PACK(s,b,f) (((b)<<6)|((s)<<3)|(f)) switch (PACK(td->td_samplesperpixel, td->td_bitspersample, td->td_sampleformat)) { case PACK(1, 32, SAMPLEFORMAT_IEEEFP): return (SGILOGDATAFMT_FLOAT); case PACK(1, 16, SAMPLEFORMAT_VOID): case PACK(1, 16, SAMPLEFORMAT_INT): case PACK(1, 16, SAMPLEFORMAT_UINT): return (SGILOGDATAFMT_16BIT); case PACK(1, 8, SAMPLEFORMAT_VOID): case PACK(1, 8, SAMPLEFORMAT_UINT): return (SGILOGDATAFMT_8BIT); } #undef PACK return (SGILOGDATAFMT_UNKNOWN); } static int LogL16InitState(TIFF* tif) { TIFFDirectory *td = &tif->tif_dir; LogLuvState* sp = DecoderState(tif); static const char module[] = "LogL16InitState"; assert(sp != NULL); assert(td->td_photometric == PHOTOMETRIC_LOGL); /* for some reason, we can't do this in TIFFInitLogL16 */ if (sp->user_datafmt == SGILOGDATAFMT_UNKNOWN) sp->user_datafmt = LogL16GuessDataFmt(td); switch (sp->user_datafmt) { case SGILOGDATAFMT_FLOAT: sp->pixel_size = sizeof (float); break; case SGILOGDATAFMT_16BIT: sp->pixel_size = sizeof (int16); break; case SGILOGDATAFMT_8BIT: sp->pixel_size = sizeof (uint8); break; default: TIFFError(tif->tif_name, "No support for converting user data format to LogL"); return (0); } sp->tbuflen = (short)(td->td_imagewidth * td->td_rowsperstrip); sp->tbuf = (tidata_t*) _TIFFmalloc(sp->tbuflen * sizeof (int16)); if (sp->tbuf == NULL) { TIFFError(module, "%s: No space for SGILog translation buffer", tif->tif_name); return (0); } return (1); } static int LogLuvGuessDataFmt(TIFFDirectory *td) { int guess; /* * If the user didn't tell us their datafmt, * take our best guess from the bitspersample. */ #define PACK(a,b) (((a)<<3)|(b)) switch (PACK(td->td_bitspersample, td->td_sampleformat)) { case PACK(32, SAMPLEFORMAT_IEEEFP): guess = SGILOGDATAFMT_FLOAT; break; case PACK(32, SAMPLEFORMAT_VOID): case PACK(32, SAMPLEFORMAT_UINT): case PACK(32, SAMPLEFORMAT_INT): guess = SGILOGDATAFMT_RAW; break; case PACK(16, SAMPLEFORMAT_VOID): case PACK(16, SAMPLEFORMAT_INT): case PACK(16, SAMPLEFORMAT_UINT): guess = SGILOGDATAFMT_16BIT; break; case PACK( 8, SAMPLEFORMAT_VOID): case PACK( 8, SAMPLEFORMAT_UINT): guess = SGILOGDATAFMT_8BIT; break; default: guess = SGILOGDATAFMT_UNKNOWN; break; #undef PACK } /* * Double-check samples per pixel. */ switch (td->td_samplesperpixel) { case 1: if (guess != SGILOGDATAFMT_RAW) guess = SGILOGDATAFMT_UNKNOWN; break; case 3: if (guess == SGILOGDATAFMT_RAW) guess = SGILOGDATAFMT_UNKNOWN; break; default: guess = SGILOGDATAFMT_UNKNOWN; break; } return (guess); } static int LogLuvInitState(TIFF* tif) { TIFFDirectory* td = &tif->tif_dir; LogLuvState* sp = DecoderState(tif); static const char module[] = "LogLuvInitState"; assert(sp != NULL); assert(td->td_photometric == PHOTOMETRIC_LOGLUV); /* for some reason, we can't do this in TIFFInitLogLuv */ if (td->td_planarconfig != PLANARCONFIG_CONTIG) { TIFFError(module, "SGILog compression cannot handle non-contiguous data"); return (0); } if (sp->user_datafmt == SGILOGDATAFMT_UNKNOWN) sp->user_datafmt = LogLuvGuessDataFmt(td); switch (sp->user_datafmt) { case SGILOGDATAFMT_FLOAT: sp->pixel_size = 3*sizeof (float); break; case SGILOGDATAFMT_16BIT: sp->pixel_size = 3*sizeof (int16); break; case SGILOGDATAFMT_RAW: sp->pixel_size = sizeof (uint32); break; case SGILOGDATAFMT_8BIT: sp->pixel_size = 3*sizeof (uint8); break; default: TIFFError(tif->tif_name, "No support for converting user data format to LogLuv"); return (0); } sp->tbuflen = (short)(td->td_imagewidth * td->td_rowsperstrip); sp->tbuf = (tidata_t*) _TIFFmalloc(sp->tbuflen * sizeof (uint32)); if (sp->tbuf == NULL) { TIFFError(module, "%s: No space for SGILog translation buffer", tif->tif_name); return (0); } return (1); } static int LogLuvSetupDecode(TIFF* tif) { LogLuvState* sp = DecoderState(tif); TIFFDirectory* td = &tif->tif_dir; tif->tif_postdecode = _TIFFNoPostDecode; switch (td->td_photometric) { case PHOTOMETRIC_LOGLUV: if (!LogLuvInitState(tif)) break; if (td->td_compression == COMPRESSION_SGILOG24) { tif->tif_decoderow = LogLuvDecode24; switch (sp->user_datafmt) { case SGILOGDATAFMT_FLOAT: sp->tfunc = Luv24toXYZ; break; case SGILOGDATAFMT_16BIT: sp->tfunc = Luv24toLuv48; break; case SGILOGDATAFMT_8BIT: sp->tfunc = Luv24toRGB; break; } } else { tif->tif_decoderow = LogLuvDecode32; switch (sp->user_datafmt) { case SGILOGDATAFMT_FLOAT: sp->tfunc = Luv32toXYZ; break; case SGILOGDATAFMT_16BIT: sp->tfunc = Luv32toLuv48; break; case SGILOGDATAFMT_8BIT: sp->tfunc = Luv32toRGB; break; } } return (1); case PHOTOMETRIC_LOGL: if (!LogL16InitState(tif)) break; tif->tif_decoderow = LogL16Decode; switch (sp->user_datafmt) { case SGILOGDATAFMT_FLOAT: sp->tfunc = L16toY; break; case SGILOGDATAFMT_8BIT: sp->tfunc = L16toGry; break; } return (1); default: TIFFError(tif->tif_name, "Inappropriate photometric interpretation %d for SGILog compression; %s", td->td_photometric, "must be either LogLUV or LogL"); break; } return (0); } static int LogLuvSetupEncode(TIFF* tif) { LogLuvState* sp = EncoderState(tif); TIFFDirectory* td = &tif->tif_dir; switch (td->td_photometric) { case PHOTOMETRIC_LOGLUV: if (!LogLuvInitState(tif)) break; if (td->td_compression == COMPRESSION_SGILOG24) { tif->tif_encoderow = LogLuvEncode24; switch (sp->user_datafmt) { case SGILOGDATAFMT_FLOAT: sp->tfunc = Luv24fromXYZ; break; case SGILOGDATAFMT_16BIT: sp->tfunc = Luv24fromLuv48; break; case SGILOGDATAFMT_RAW: break; default: goto notsupported; } } else { tif->tif_encoderow = LogLuvEncode32; switch (sp->user_datafmt) { case SGILOGDATAFMT_FLOAT: sp->tfunc = Luv32fromXYZ; break; case SGILOGDATAFMT_16BIT: sp->tfunc = Luv32fromLuv48; break; case SGILOGDATAFMT_RAW: break; default: goto notsupported; } } break; case PHOTOMETRIC_LOGL: if (!LogL16InitState(tif)) break; tif->tif_encoderow = LogL16Encode; switch (sp->user_datafmt) { case SGILOGDATAFMT_FLOAT: sp->tfunc = L16fromY; break; case SGILOGDATAFMT_16BIT: break; default: goto notsupported; } break; default: TIFFError(tif->tif_name, "Inappropriate photometric interpretation %d for SGILog compression; %s", td->td_photometric, "must be either LogLUV or LogL"); break; } return (1); notsupported: TIFFError(tif->tif_name, "SGILog compression supported only for %s, or raw data", td->td_photometric == PHOTOMETRIC_LOGL ? "Y, L" : "XYZ, Luv"); return (0); } static void LogLuvClose(TIFF* tif) { TIFFDirectory *td = &tif->tif_dir; /* * For consistency, we always want to write out the same * bitspersample and sampleformat for our TIFF file, * regardless of the data format being used by the application. * Since this routine is called after tags have been set but * before they have been recorded in the file, we reset them here. */ td->td_samplesperpixel = (td->td_photometric == PHOTOMETRIC_LOGL) ? 1 : 3; td->td_bitspersample = 16; td->td_sampleformat = SAMPLEFORMAT_INT; } static void LogLuvCleanup(TIFF* tif) { LogLuvState* sp = (LogLuvState *)tif->tif_data; if (sp) { if (sp->tbuf) _TIFFfree(sp->tbuf); _TIFFfree(sp); tif->tif_data = NULL; } } static int LogLuvVSetField(TIFF* tif, ttag_t tag, va_list ap) { LogLuvState* sp = DecoderState(tif); int bps, fmt; switch (tag) { case TIFFTAG_SGILOGDATAFMT: sp->user_datafmt = va_arg(ap, int); /* * Tweak the TIFF header so that the rest of libtiff knows what * size of data will be passed between app and library, and * assume that the app knows what it is doing and is not * confused by these header manipulations... */ switch (sp->user_datafmt) { case SGILOGDATAFMT_FLOAT: bps = 32, fmt = SAMPLEFORMAT_IEEEFP; break; case SGILOGDATAFMT_16BIT: bps = 16, fmt = SAMPLEFORMAT_INT; break; case SGILOGDATAFMT_RAW: bps = 32, fmt = SAMPLEFORMAT_UINT; break; case SGILOGDATAFMT_8BIT: bps = 8, fmt = SAMPLEFORMAT_UINT; break; default: TIFFError(tif->tif_name, "Unknown data format %d for LogLuv compression", sp->user_datafmt); return (0); } TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bps); TIFFSetField(tif, TIFFTAG_SAMPLEFORMAT, fmt); /* * Must recalculate sizes should bits/sample change. */ tif->tif_tilesize = TIFFTileSize(tif); tif->tif_scanlinesize = TIFFScanlineSize(tif); return (1); default: return (*sp->vsetparent)(tif, tag, ap); } } static int LogLuvVGetField(TIFF* tif, ttag_t tag, va_list ap) { LogLuvState *sp = (LogLuvState *)tif->tif_data; switch (tag) { case TIFFTAG_SGILOGDATAFMT: *va_arg(ap, int*) = sp->user_datafmt; return (1); default: return (*sp->vgetparent)(tif, tag, ap); } } static const TIFFFieldInfo LogLuvFieldInfo[] = { { TIFFTAG_SGILOGDATAFMT, 0, 0, TIFF_SHORT, FIELD_PSEUDO, TRUE, FALSE, "SGILogDataFmt"} }; int TIFFInitSGILog(TIFF* tif, int scheme) { static const char module[] = "TIFFInitSGILog"; LogLuvState* sp; assert(scheme == COMPRESSION_SGILOG24 || scheme == COMPRESSION_SGILOG); /* * Allocate state block so tag methods have storage to record values. */ tif->tif_data = (tidata_t) _TIFFmalloc(sizeof (LogLuvState)); if (tif->tif_data == NULL) goto bad; sp = (LogLuvState*) tif->tif_data; memset(sp, 0, sizeof (*sp)); sp->user_datafmt = SGILOGDATAFMT_UNKNOWN; sp->tfunc = _logLuvNop; /* * Install codec methods. * NB: tif_decoderow & tif_encoderow are filled * in at setup time. */ tif->tif_setupdecode = LogLuvSetupDecode; tif->tif_decodestrip = LogLuvDecodeStrip; tif->tif_decodetile = LogLuvDecodeTile; tif->tif_setupencode = LogLuvSetupEncode; tif->tif_encodestrip = LogLuvEncodeStrip; tif->tif_encodetile = LogLuvEncodeTile; tif->tif_close = LogLuvClose; tif->tif_cleanup = LogLuvCleanup; /* override SetField so we can handle our private pseudo-tag */ _TIFFMergeFieldInfo(tif, LogLuvFieldInfo, N(LogLuvFieldInfo)); sp->vgetparent = tif->tif_vgetfield; tif->tif_vgetfield = LogLuvVGetField; /* hook for codec tags */ sp->vsetparent = tif->tif_vsetfield; tif->tif_vsetfield = LogLuvVSetField; /* hook for codec tags */ return (1); bad: TIFFError(module, "%s: No space for LogLuv state block", tif->tif_name); return (0); } #endif /* LOGLUV_SUPPORT */ netpbm-8.2/libtiff/tif_lzw.c0100660000076400000000000004717207027537703015154 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_lzw.c,v 1.5 1999/12/20 23:46:11 mwelles Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #include "tiffiop.h" #ifdef LZW_SUPPORT /* * TIFF Library. * Rev 5.0 Lempel-Ziv & Welch Compression Support * * This code is derived from the compress program whose code is * derived from software contributed to Berkeley by James A. Woods, * derived from original work by Spencer Thomas and Joseph Orost. * * The original Berkeley copyright notice appears below in its entirety. */ #include "tif_predict.h" #include #include /* * NB: The 5.0 spec describes a different algorithm than Aldus * implements. Specifically, Aldus does code length transitions * one code earlier than should be done (for real LZW). * Earlier versions of this library implemented the correct * LZW algorithm, but emitted codes in a bit order opposite * to the TIFF spec. Thus, to maintain compatibility w/ Aldus * we interpret MSB-LSB ordered codes to be images written w/ * old versions of this library, but otherwise adhere to the * Aldus "off by one" algorithm. * * Future revisions to the TIFF spec are expected to "clarify this issue". */ #define LZW_COMPAT /* include backwards compatibility code */ /* * Each strip of data is supposed to be terminated by a CODE_EOI. * If the following #define is included, the decoder will also * check for end-of-strip w/o seeing this code. This makes the * library more robust, but also slower. */ #define LZW_CHECKEOS /* include checks for strips w/o EOI code */ #define MAXCODE(n) ((1L<<(n))-1) /* * The TIFF spec specifies that encoded bit * strings range from 9 to 12 bits. */ #define BITS_MIN 9 /* start with 9 bits */ #define BITS_MAX 12 /* max of 12 bit strings */ /* predefined codes */ #define CODE_CLEAR 256 /* code to clear string table */ #define CODE_EOI 257 /* end-of-information code */ #define CODE_FIRST 258 /* first free code entry */ #define CODE_MAX MAXCODE(BITS_MAX) #define HSIZE 9001L /* 91% occupancy */ #define HSHIFT (13-8) #ifdef LZW_COMPAT /* NB: +1024 is for compatibility with old files */ #define CSIZE (MAXCODE(BITS_MAX)+1024L) #else #define CSIZE (MAXCODE(BITS_MAX)+1L) #endif /* * State block for each open TIFF file using LZW * compression/decompression. Note that the predictor * state block must be first in this data structure. */ typedef struct { TIFFPredictorState predict; /* predictor super class */ u_short nbits; /* # of bits/code */ u_short maxcode; /* maximum code for lzw_nbits */ u_short free_ent; /* next free entry in hash table */ long nextdata; /* next bits of i/o */ long nextbits; /* # of valid bits in lzw_nextdata */ } LZWBaseState; #define lzw_nbits base.nbits #define lzw_maxcode base.maxcode #define lzw_free_ent base.free_ent #define lzw_nextdata base.nextdata #define lzw_nextbits base.nextbits /* * Decoding-specific state. */ typedef struct code_ent { struct code_ent *next; u_short length; /* string len, including this token */ u_char value; /* data value */ u_char firstchar; /* first token of string */ } code_t; typedef int (*decodeFunc)(TIFF*, tidata_t, tsize_t, tsample_t); typedef struct { LZWBaseState base; long dec_nbitsmask; /* lzw_nbits 1 bits, right adjusted */ long dec_restart; /* restart count */ #ifdef LZW_CHECKEOS long dec_bitsleft; /* available bits in raw data */ #endif decodeFunc dec_decode; /* regular or backwards compatible */ code_t* dec_codep; /* current recognized code */ code_t* dec_oldcodep; /* previously recognized code */ code_t* dec_free_entp; /* next free entry */ code_t* dec_maxcodep; /* max available entry */ code_t* dec_codetab; /* kept separate for small machines */ } LZWDecodeState; /* * Encoding-specific state. */ typedef uint16 hcode_t; /* codes fit in 16 bits */ typedef struct { long hash; hcode_t code; } hash_t; typedef struct { LZWBaseState base; int enc_oldcode; /* last code encountered */ long enc_checkpoint; /* point at which to clear table */ #define CHECK_GAP 10000 /* enc_ratio check interval */ long enc_ratio; /* current compression ratio */ long enc_incount; /* (input) data bytes encoded */ long enc_outcount; /* encoded (output) bytes */ tidata_t enc_rawlimit; /* bound on tif_rawdata buffer */ hash_t* enc_hashtab; /* kept separate for small machines */ } LZWEncodeState; #define LZWState(tif) ((LZWBaseState*) (tif)->tif_data) #define DecoderState(tif) ((LZWDecodeState*) LZWState(tif)) #define EncoderState(tif) ((LZWEncodeState*) LZWState(tif)) static int LZWDecode(TIFF*, tidata_t, tsize_t, tsample_t); #ifdef LZW_COMPAT static int LZWDecodeCompat(TIFF*, tidata_t, tsize_t, tsample_t); #endif static void cl_hash(LZWEncodeState*); /* * LZW Decoder. */ #ifdef LZW_CHECKEOS /* * This check shouldn't be necessary because each * strip is suppose to be terminated with CODE_EOI. */ #define NextCode(_tif, _sp, _bp, _code, _get) { \ if ((_sp)->dec_bitsleft < nbits) { \ TIFFWarning(_tif->tif_name, \ "LZWDecode: Strip %d not terminated with EOI code", \ _tif->tif_curstrip); \ _code = CODE_EOI; \ } else { \ _get(_sp,_bp,_code); \ (_sp)->dec_bitsleft -= nbits; \ } \ } #else #define NextCode(tif, sp, bp, code, get) get(sp, bp, code) #endif static int LZWSetupDecode(TIFF* tif) { LZWDecodeState* sp = DecoderState(tif); static const char module[] = " LZWSetupDecode"; int code; assert(sp != NULL); if (sp->dec_codetab == NULL) { sp->dec_codetab = (code_t*)_TIFFmalloc(CSIZE*sizeof (code_t)); if (sp->dec_codetab == NULL) { TIFFError(module, "No space for LZW code table"); return (0); } /* * Pre-load the table. */ for (code = 255; code >= 0; code--) { sp->dec_codetab[code].value = code; sp->dec_codetab[code].firstchar = code; sp->dec_codetab[code].length = 1; sp->dec_codetab[code].next = NULL; } } return (1); } /* * Setup state for decoding a strip. */ static int LZWPreDecode(TIFF* tif, tsample_t s) { LZWDecodeState *sp = DecoderState(tif); (void) s; assert(sp != NULL); /* * Check for old bit-reversed codes. */ if (tif->tif_rawdata[0] == 0 && (tif->tif_rawdata[1] & 0x1)) { #ifdef LZW_COMPAT if (!sp->dec_decode) { TIFFWarning(tif->tif_name, "Old-style LZW codes, convert file"); /* * Override default decoding methods with * ones that deal with the old coding. * Otherwise the predictor versions set * above will call the compatibility routines * through the dec_decode method. */ tif->tif_decoderow = LZWDecodeCompat; tif->tif_decodestrip = LZWDecodeCompat; tif->tif_decodetile = LZWDecodeCompat; /* * If doing horizontal differencing, must * re-setup the predictor logic since we * switched the basic decoder methods... */ (*tif->tif_setupdecode)(tif); sp->dec_decode = LZWDecodeCompat; } sp->lzw_maxcode = MAXCODE(BITS_MIN); #else /* !LZW_COMPAT */ if (!sp->dec_decode) { TIFFError(tif->tif_name, "Old-style LZW codes not supported"); sp->dec_decode = LZWDecode; } return (0); #endif/* !LZW_COMPAT */ } else { sp->lzw_maxcode = MAXCODE(BITS_MIN)-1; sp->dec_decode = LZWDecode; } sp->lzw_nbits = BITS_MIN; sp->lzw_nextbits = 0; sp->lzw_nextdata = 0; sp->dec_restart = 0; sp->dec_nbitsmask = MAXCODE(BITS_MIN); #ifdef LZW_CHECKEOS sp->dec_bitsleft = tif->tif_rawcc << 3; #endif sp->dec_free_entp = sp->dec_codetab + CODE_FIRST; /* * Zero entries that are not yet filled in. We do * this to guard against bogus input data that causes * us to index into undefined entries. If you can * come up with a way to safely bounds-check input codes * while decoding then you can remove this operation. */ _TIFFmemset(sp->dec_free_entp, 0, (CSIZE-CODE_FIRST)*sizeof (code_t)); sp->dec_oldcodep = &sp->dec_codetab[-1]; sp->dec_maxcodep = &sp->dec_codetab[sp->dec_nbitsmask-1]; return (1); } /* * Decode a "hunk of data". */ #define GetNextCode(sp, bp, code) { \ nextdata = (nextdata<<8) | *(bp)++; \ nextbits += 8; \ if (nextbits < nbits) { \ nextdata = (nextdata<<8) | *(bp)++; \ nextbits += 8; \ } \ code = (hcode_t)((nextdata >> (nextbits-nbits)) & nbitsmask); \ nextbits -= nbits; \ } static void codeLoop(TIFF* tif) { TIFFError(tif->tif_name, "LZWDecode: Bogus encoding, loop in the code table; scanline %d", tif->tif_row); } static int LZWDecode(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) { LZWDecodeState *sp = DecoderState(tif); char *op = (char*) op0; long occ = (long) occ0; char *tp; u_char *bp; hcode_t code; int len; long nbits, nextbits, nextdata, nbitsmask; code_t *codep, *free_entp, *maxcodep, *oldcodep; (void) s; assert(sp != NULL); /* * Restart interrupted output operation. */ if (sp->dec_restart) { long residue; codep = sp->dec_codep; residue = codep->length - sp->dec_restart; if (residue > occ) { /* * Residue from previous decode is sufficient * to satisfy decode request. Skip to the * start of the decoded string, place decoded * values in the output buffer, and return. */ sp->dec_restart += occ; do { codep = codep->next; } while (--residue > occ && codep); if (codep) { tp = op + occ; do { *--tp = codep->value; codep = codep->next; } while (--occ && codep); } return (1); } /* * Residue satisfies only part of the decode request. */ op += residue, occ -= residue; tp = op; do { int t; --tp; t = codep->value; codep = codep->next; *tp = t; } while (--residue && codep); sp->dec_restart = 0; } bp = (u_char *)tif->tif_rawcp; nbits = sp->lzw_nbits; nextdata = sp->lzw_nextdata; nextbits = sp->lzw_nextbits; nbitsmask = sp->dec_nbitsmask; oldcodep = sp->dec_oldcodep; free_entp = sp->dec_free_entp; maxcodep = sp->dec_maxcodep; while (occ > 0) { NextCode(tif, sp, bp, code, GetNextCode); if (code == CODE_EOI) break; if (code == CODE_CLEAR) { free_entp = sp->dec_codetab + CODE_FIRST; nbits = BITS_MIN; nbitsmask = MAXCODE(BITS_MIN); maxcodep = sp->dec_codetab + nbitsmask-1; NextCode(tif, sp, bp, code, GetNextCode); if (code == CODE_EOI) break; *op++ = (char) code, occ--; oldcodep = sp->dec_codetab + code; continue; } codep = sp->dec_codetab + code; /* * Add the new entry to the code table. */ assert(&sp->dec_codetab[0] <= free_entp && free_entp < &sp->dec_codetab[CSIZE]); free_entp->next = oldcodep; free_entp->firstchar = free_entp->next->firstchar; free_entp->length = free_entp->next->length+1; free_entp->value = (codep < free_entp) ? codep->firstchar : free_entp->firstchar; if (++free_entp > maxcodep) { if (++nbits > BITS_MAX) /* should not happen */ nbits = BITS_MAX; nbitsmask = MAXCODE(nbits); maxcodep = sp->dec_codetab + nbitsmask-1; } oldcodep = codep; if (code >= 256) { /* * Code maps to a string, copy string * value to output (written in reverse). */ if (codep->length > occ) { /* * String is too long for decode buffer, * locate portion that will fit, copy to * the decode buffer, and setup restart * logic for the next decoding call. */ sp->dec_codep = codep; do { codep = codep->next; } while (codep && codep->length > occ); if (codep) { sp->dec_restart = occ; tp = op + occ; do { *--tp = codep->value; codep = codep->next; } while (--occ && codep); if (codep) codeLoop(tif); } break; } len = codep->length; tp = op + len; do { int t; --tp; t = codep->value; codep = codep->next; *tp = t; } while (codep && tp > op); if (codep) { codeLoop(tif); break; } op += len, occ -= len; } else *op++ = (char) code, occ--; } tif->tif_rawcp = (tidata_t) bp; sp->lzw_nbits = (u_short) nbits; sp->lzw_nextdata = nextdata; sp->lzw_nextbits = nextbits; sp->dec_nbitsmask = nbitsmask; sp->dec_oldcodep = oldcodep; sp->dec_free_entp = free_entp; sp->dec_maxcodep = maxcodep; if (occ > 0) { TIFFError(tif->tif_name, "LZWDecode: Not enough data at scanline %d (short %d bytes)", tif->tif_row, occ); return (0); } return (1); } #ifdef LZW_COMPAT /* * Decode a "hunk of data" for old images. */ #define GetNextCodeCompat(sp, bp, code) { \ nextdata |= (u_long) *(bp)++ << nextbits; \ nextbits += 8; \ if (nextbits < nbits) { \ nextdata |= (u_long) *(bp)++ << nextbits; \ nextbits += 8; \ } \ code = (hcode_t)(nextdata & nbitsmask); \ nextdata >>= nbits; \ nextbits -= nbits; \ } static int LZWDecodeCompat(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) { LZWDecodeState *sp = DecoderState(tif); char *op = (char*) op0; long occ = (long) occ0; char *tp; u_char *bp; int code, nbits; long nextbits, nextdata, nbitsmask; code_t *codep, *free_entp, *maxcodep, *oldcodep; (void) s; assert(sp != NULL); /* * Restart interrupted output operation. */ if (sp->dec_restart) { long residue; codep = sp->dec_codep; residue = codep->length - sp->dec_restart; if (residue > occ) { /* * Residue from previous decode is sufficient * to satisfy decode request. Skip to the * start of the decoded string, place decoded * values in the output buffer, and return. */ sp->dec_restart += occ; do { codep = codep->next; } while (--residue > occ); tp = op + occ; do { *--tp = codep->value; codep = codep->next; } while (--occ); return (1); } /* * Residue satisfies only part of the decode request. */ op += residue, occ -= residue; tp = op; do { *--tp = codep->value; codep = codep->next; } while (--residue); sp->dec_restart = 0; } bp = (u_char *)tif->tif_rawcp; nbits = sp->lzw_nbits; nextdata = sp->lzw_nextdata; nextbits = sp->lzw_nextbits; nbitsmask = sp->dec_nbitsmask; oldcodep = sp->dec_oldcodep; free_entp = sp->dec_free_entp; maxcodep = sp->dec_maxcodep; while (occ > 0) { NextCode(tif, sp, bp, code, GetNextCodeCompat); if (code == CODE_EOI) break; if (code == CODE_CLEAR) { free_entp = sp->dec_codetab + CODE_FIRST; nbits = BITS_MIN; nbitsmask = MAXCODE(BITS_MIN); maxcodep = sp->dec_codetab + nbitsmask; NextCode(tif, sp, bp, code, GetNextCodeCompat); if (code == CODE_EOI) break; *op++ = code, occ--; oldcodep = sp->dec_codetab + code; continue; } codep = sp->dec_codetab + code; /* * Add the new entry to the code table. */ assert(&sp->dec_codetab[0] <= free_entp && free_entp < &sp->dec_codetab[CSIZE]); free_entp->next = oldcodep; free_entp->firstchar = free_entp->next->firstchar; free_entp->length = free_entp->next->length+1; free_entp->value = (codep < free_entp) ? codep->firstchar : free_entp->firstchar; if (++free_entp > maxcodep) { if (++nbits > BITS_MAX) /* should not happen */ nbits = BITS_MAX; nbitsmask = MAXCODE(nbits); maxcodep = sp->dec_codetab + nbitsmask; } oldcodep = codep; if (code >= 256) { /* * Code maps to a string, copy string * value to output (written in reverse). */ if (codep->length > occ) { /* * String is too long for decode buffer, * locate portion that will fit, copy to * the decode buffer, and setup restart * logic for the next decoding call. */ sp->dec_codep = codep; do { codep = codep->next; } while (codep->length > occ); sp->dec_restart = occ; tp = op + occ; do { *--tp = codep->value; codep = codep->next; } while (--occ); break; } op += codep->length, occ -= codep->length; tp = op; do { *--tp = codep->value; } while( (codep = codep->next) != NULL); } else *op++ = code, occ--; } tif->tif_rawcp = (tidata_t) bp; sp->lzw_nbits = nbits; sp->lzw_nextdata = nextdata; sp->lzw_nextbits = nextbits; sp->dec_nbitsmask = nbitsmask; sp->dec_oldcodep = oldcodep; sp->dec_free_entp = free_entp; sp->dec_maxcodep = maxcodep; if (occ > 0) { TIFFError(tif->tif_name, "LZWDecodeCompat: Not enough data at scanline %d (short %d bytes)", tif->tif_row, occ); return (0); } return (1); } static int _LZWtrue(TIFF* tif) { (void) tif; return (1); } #endif /* LZW_COMPAT */ /* * LZW Encoding. * * LZW Encoding Removed 11/22/99 due to Unisys's control of patent, * and their demand for payment even from software developers. * */ static void LZWCleanup(TIFF* tif) { if (tif->tif_data) { if (tif->tif_mode == O_RDONLY) { if (DecoderState(tif)->dec_codetab) _TIFFfree(DecoderState(tif)->dec_codetab); } _TIFFfree(tif->tif_data); tif->tif_data = NULL; } } int TIFFInitLZW(TIFF* tif, int scheme) { assert(scheme == COMPRESSION_LZW); /* * Allocate state block so tag methods have storage to record values. */ tif->tif_data = (tidata_t) _TIFFmalloc(sizeof (LZWDecodeState)); if (tif->tif_data == NULL) goto bad; if (tif->tif_mode == O_RDONLY) { DecoderState(tif)->dec_codetab = NULL; DecoderState(tif)->dec_decode = NULL; } /* * Install codec methods. */ tif->tif_setupdecode = LZWSetupDecode; tif->tif_predecode = LZWPreDecode; tif->tif_decoderow = LZWDecode; tif->tif_decodestrip = LZWDecode; tif->tif_decodetile = LZWDecode; tif->tif_setupencode = _LZWtrue; tif->tif_preencode = _TIFFNoPreCode; tif->tif_postencode = _LZWtrue; tif->tif_encoderow = _TIFFNoRowEncode; tif->tif_encodestrip = _TIFFNoStripEncode; tif->tif_encodetile = _TIFFNoTileEncode; tif->tif_cleanup = LZWCleanup; /* * Setup predictor setup. */ (void) TIFFPredictorInit(tif); return (1); bad: TIFFError("TIFFInitLZW", "No space for LZW state block"); return (0); } /* * Copyright (c) 1985, 1986 The Regents of the University of California. * All rights reserved. * * This code is derived from software contributed to Berkeley by * James A. Woods, derived from original work by Spencer Thomas * and Joseph Orost. * * Redistribution and use in source and binary forms are permitted * provided that the above copyright notice and this paragraph are * duplicated in all such forms and that any documentation, * advertising materials, and other materials related to such * distribution and use acknowledge that the software was developed * by the University of California, Berkeley. The name of the * University may not be used to endorse or promote products derived * from this software without specific prior written permission. * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. */ #endif /* LZW_SUPPORT */ netpbm-8.2/libtiff/tif_msdos.c0100660000076400000000000000777106747424643015474 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_msdos.c,v 1.1.1.1 1999/07/27 21:50:27 mike Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library MSDOS-specific Routines. */ #if defined(__WATCOMC__) || defined(__BORLANDC__) || defined(_MSC_VER) #include /* for open, close, etc. function prototypes */ #include #endif #include "tiffiop.h" static tsize_t _tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size) { return (read((int) fd, buf, size)); } static tsize_t _tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size) { return (write((int) fd, buf, size)); } static toff_t _tiffSeekProc(thandle_t fd, toff_t off, int whence) { return (lseek((int) fd, (off_t) off, whence)); } static int _tiffCloseProc(thandle_t fd) { return (close((int) fd)); } #include static toff_t _tiffSizeProc(thandle_t fd) { struct stat sb; return (fstat((int) fd, &sb) < 0 ? 0 : sb.st_size); } static int _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) { return (0); } static void _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size) { } /* * Open a TIFF file descriptor for read/writing. */ TIFF* TIFFFdOpen(int fd, const char* name, const char* mode) { TIFF* tif; tif = TIFFClientOpen(name, mode, (void*) fd, _tiffReadProc, _tiffWriteProc, _tiffSeekProc, _tiffCloseProc, _tiffSizeProc, _tiffMapProc, _tiffUnmapProc); if (tif) tif->tif_fd = fd; return (tif); } /* * Open a TIFF file for read/writing. */ TIFF* TIFFOpen(const char* name, const char* mode) { static const char module[] = "TIFFOpen"; int m, fd; m = _TIFFgetMode(mode, module); if (m == -1) return ((TIFF*)0); fd = open(name, m|O_BINARY, 0666); if (fd < 0) { TIFFError(module, "%s: Cannot open", name); return ((TIFF*)0); } return (TIFFFdOpen(fd, name, mode)); } #ifdef __GNUC__ extern char* malloc(); extern char* realloc(); #else #include #endif tdata_t _TIFFmalloc(tsize_t s) { return (malloc((size_t) s)); } void _TIFFfree(tdata_t p) { free(p); } tdata_t _TIFFrealloc(tdata_t p, tsize_t s) { return (realloc(p, (size_t) s)); } void _TIFFmemset(tdata_t p, int v, tsize_t c) { memset(p, v, (size_t) c); } void _TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c) { memcpy(d, s, (size_t) c); } int _TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c) { return (memcmp(p1, p2, (size_t) c)); } static void msdosWarningHandler(const char* module, const char* fmt, va_list ap) { if (module != NULL) fprintf(stderr, "%s: ", module); fprintf(stderr, "Warning, "); vfprintf(stderr, fmt, ap); fprintf(stderr, ".\n"); } TIFFErrorHandler _TIFFwarningHandler = msdosWarningHandler; static void msdosErrorHandler(const char* module, const char* fmt, va_list ap) { if (module != NULL) fprintf(stderr, "%s: ", module); vfprintf(stderr, fmt, ap); fprintf(stderr, ".\n"); } TIFFErrorHandler _TIFFerrorHandler = msdosErrorHandler; netpbm-8.2/libtiff/tif_next.c0100660000076400000000000000725207020050200015260 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_next.c,v 1.2 1999/11/27 21:43:28 warmerda Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #include "tiffiop.h" #ifdef NEXT_SUPPORT /* * TIFF Library. * * NeXT 2-bit Grey Scale Compression Algorithm Support */ #define SETPIXEL(op, v) { \ switch (npixels++ & 3) { \ case 0: op[0] = (v) << 6; break; \ case 1: op[0] |= (v) << 4; break; \ case 2: op[0] |= (v) << 2; break; \ case 3: *op++ |= (v); break; \ } \ } #define LITERALROW 0x00 #define LITERALSPAN 0x40 #define WHITE ((1<<2)-1) static int NeXTDecode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s) { register u_char *bp, *op; register tsize_t cc; register int n; tidata_t row; tsize_t scanline; (void) s; /* * Each scanline is assumed to start off as all * white (we assume a PhotometricInterpretation * of ``min-is-black''). */ for (op = buf, cc = occ; cc-- > 0;) *op++ = 0xff; bp = (u_char *)tif->tif_rawcp; cc = tif->tif_rawcc; scanline = tif->tif_scanlinesize; for (row = buf; (long)occ > 0; occ -= scanline, row += scanline) { n = *bp++, cc--; switch (n) { case LITERALROW: /* * The entire scanline is given as literal values. */ if (cc < scanline) goto bad; _TIFFmemcpy(row, bp, scanline); bp += scanline; cc -= scanline; break; case LITERALSPAN: { int off; /* * The scanline has a literal span * that begins at some offset. */ off = (bp[0] * 256) + bp[1]; n = (bp[2] * 256) + bp[3]; if (cc < 4+n) goto bad; _TIFFmemcpy(row+off, bp+4, n); bp += 4+n; cc -= 4+n; break; } default: { register int npixels = 0, grey; u_long imagewidth = tif->tif_dir.td_imagewidth; /* * The scanline is composed of a sequence * of constant color ``runs''. We shift * into ``run mode'' and interpret bytes * as codes of the form * until we've filled the scanline. */ op = row; for (;;) { grey = (n>>6) & 0x3; n &= 0x3f; while (n-- > 0) SETPIXEL(op, grey); if (npixels >= (int) imagewidth) break; if (cc == 0) goto bad; n = *bp++, cc--; } break; } } } tif->tif_rawcp = (tidata_t) bp; tif->tif_rawcc = cc; return (1); bad: TIFFError(tif->tif_name, "NeXTDecode: Not enough data for scanline %ld", (long) tif->tif_row); return (0); } int TIFFInitNeXT(TIFF* tif, int scheme) { (void) scheme; tif->tif_decoderow = NeXTDecode; tif->tif_decodestrip = NeXTDecode; tif->tif_decodetile = NeXTDecode; return (1); } #endif /* NEXT_SUPPORT */ netpbm-8.2/libtiff/tif_open.c0100660000076400000000000003047106765531726015302 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_open.c,v 1.2 1999/09/08 19:07:02 warmerda Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library. */ #include "tiffiop.h" void _TIFFSetDefaultCompressionState(TIFF* tif); static const long typemask[13] = { 0L, /* TIFF_NOTYPE */ 0x000000ffL, /* TIFF_BYTE */ 0xffffffffL, /* TIFF_ASCII */ 0x0000ffffL, /* TIFF_SHORT */ 0xffffffffL, /* TIFF_LONG */ 0xffffffffL, /* TIFF_RATIONAL */ 0x000000ffL, /* TIFF_SBYTE */ 0x000000ffL, /* TIFF_UNDEFINED */ 0x0000ffffL, /* TIFF_SSHORT */ 0xffffffffL, /* TIFF_SLONG */ 0xffffffffL, /* TIFF_SRATIONAL */ 0xffffffffL, /* TIFF_FLOAT */ 0xffffffffL, /* TIFF_DOUBLE */ }; static const int bigTypeshift[13] = { 0, /* TIFF_NOTYPE */ 24, /* TIFF_BYTE */ 0, /* TIFF_ASCII */ 16, /* TIFF_SHORT */ 0, /* TIFF_LONG */ 0, /* TIFF_RATIONAL */ 24, /* TIFF_SBYTE */ 24, /* TIFF_UNDEFINED */ 16, /* TIFF_SSHORT */ 0, /* TIFF_SLONG */ 0, /* TIFF_SRATIONAL */ 0, /* TIFF_FLOAT */ 0, /* TIFF_DOUBLE */ }; static const int litTypeshift[13] = { 0, /* TIFF_NOTYPE */ 0, /* TIFF_BYTE */ 0, /* TIFF_ASCII */ 0, /* TIFF_SHORT */ 0, /* TIFF_LONG */ 0, /* TIFF_RATIONAL */ 0, /* TIFF_SBYTE */ 0, /* TIFF_UNDEFINED */ 0, /* TIFF_SSHORT */ 0, /* TIFF_SLONG */ 0, /* TIFF_SRATIONAL */ 0, /* TIFF_FLOAT */ 0, /* TIFF_DOUBLE */ }; /* * Initialize the shift & mask tables, and the * byte swapping state according to the file * contents and the machine architecture. */ static void TIFFInitOrder(TIFF* tif, int magic, int bigendian) { tif->tif_typemask = typemask; if (magic == TIFF_BIGENDIAN) { tif->tif_typeshift = bigTypeshift; if (!bigendian) tif->tif_flags |= TIFF_SWAB; } else { tif->tif_typeshift = litTypeshift; if (bigendian) tif->tif_flags |= TIFF_SWAB; } } int _TIFFgetMode(const char* mode, const char* module) { int m = -1; switch (mode[0]) { case 'r': m = O_RDONLY; if (mode[1] == '+') m = O_RDWR; break; case 'w': case 'a': m = O_RDWR|O_CREAT; if (mode[0] == 'w') m |= O_TRUNC; break; default: TIFFError(module, "\"%s\": Bad mode", mode); break; } return (m); } TIFF* TIFFClientOpen( const char* name, const char* mode, thandle_t clientdata, TIFFReadWriteProc readproc, TIFFReadWriteProc writeproc, TIFFSeekProc seekproc, TIFFCloseProc closeproc, TIFFSizeProc sizeproc, TIFFMapFileProc mapproc, TIFFUnmapFileProc unmapproc ) { static const char module[] = "TIFFClientOpen"; TIFF *tif; int m, bigendian; const char* cp; m = _TIFFgetMode(mode, module); if (m == -1) goto bad2; tif = (TIFF *)_TIFFmalloc(sizeof (TIFF) + strlen(name) + 1); if (tif == NULL) { TIFFError(module, "%s: Out of memory (TIFF structure)", name); goto bad2; } _TIFFmemset(tif, 0, sizeof (*tif)); tif->tif_name = (char *)tif + sizeof (TIFF); strcpy(tif->tif_name, name); tif->tif_mode = m &~ (O_CREAT|O_TRUNC); tif->tif_curdir = (tdir_t) -1; /* non-existent directory */ tif->tif_curoff = 0; tif->tif_curstrip = (tstrip_t) -1; /* invalid strip */ tif->tif_row = (uint32) -1; /* read/write pre-increment */ tif->tif_clientdata = clientdata; tif->tif_readproc = readproc; tif->tif_writeproc = writeproc; tif->tif_seekproc = seekproc; tif->tif_closeproc = closeproc; tif->tif_sizeproc = sizeproc; tif->tif_mapproc = mapproc; tif->tif_unmapproc = unmapproc; _TIFFSetDefaultCompressionState(tif); /* setup default state */ /* * Default is to return data MSB2LSB and enable the * use of memory-mapped files and strip chopping when * a file is opened read-only. */ tif->tif_flags = FILLORDER_MSB2LSB; if (m == O_RDONLY) #ifdef STRIPCHOP_DEFAULT tif->tif_flags |= TIFF_MAPPED|STRIPCHOP_DEFAULT; #else tif->tif_flags |= TIFF_MAPPED; #endif { union { int32 i; char c[4]; } u; u.i = 1; bigendian = u.c[0] == 0; } /* * Process library-specific flags in the open mode string. * The following flags may be used to control intrinsic library * behaviour that may or may not be desirable (usually for * compatibility with some application that claims to support * TIFF but only supports some braindead idea of what the * vendor thinks TIFF is): * * 'l' use little-endian byte order for creating a file * 'b' use big-endian byte order for creating a file * 'L' read/write information using LSB2MSB bit order * 'B' read/write information using MSB2LSB bit order * 'H' read/write information using host bit order * 'M' enable use of memory-mapped files when supported * 'm' disable use of memory-mapped files * 'C' enable strip chopping support when reading * 'c' disable strip chopping support * * The use of the 'l' and 'b' flags is strongly discouraged. * These flags are provided solely because numerous vendors, * typically on the PC, do not correctly support TIFF; they * only support the Intel little-endian byte order. This * support is not configured by default because it supports * the violation of the TIFF spec that says that readers *MUST* * support both byte orders. It is strongly recommended that * you not use this feature except to deal with busted apps * that write invalid TIFF. And even in those cases you should * bang on the vendors to fix their software. * * The 'L', 'B', and 'H' flags are intended for applications * that can optimize operations on data by using a particular * bit order. By default the library returns data in MSB2LSB * bit order for compatibiltiy with older versions of this * library. Returning data in the bit order of the native cpu * makes the most sense but also requires applications to check * the value of the FillOrder tag; something they probabyl do * not do right now. * * The 'M' and 'm' flags are provided because some virtual memory * systems exhibit poor behaviour when large images are mapped. * These options permit clients to control the use of memory-mapped * files on a per-file basis. * * The 'C' and 'c' flags are provided because the library support * for chopping up large strips into multiple smaller strips is not * application-transparent and as such can cause problems. The 'c' * option permits applications that only want to look at the tags, * for example, to get the unadulterated TIFF tag information. */ for (cp = mode; *cp; cp++) switch (*cp) { case 'b': if ((m&O_CREAT) && !bigendian) tif->tif_flags |= TIFF_SWAB; break; case 'l': if ((m&O_CREAT) && bigendian) tif->tif_flags |= TIFF_SWAB; break; case 'B': tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) | FILLORDER_MSB2LSB; break; case 'L': tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) | FILLORDER_LSB2MSB; break; case 'H': tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) | HOST_FILLORDER; break; case 'M': if (m == O_RDONLY) tif->tif_flags |= TIFF_MAPPED; break; case 'm': if (m == O_RDONLY) tif->tif_flags &= ~TIFF_MAPPED; break; case 'C': if (m == O_RDONLY) tif->tif_flags |= TIFF_STRIPCHOP; break; case 'c': if (m == O_RDONLY) tif->tif_flags &= ~TIFF_STRIPCHOP; break; } /* * Read in TIFF header. */ if (!ReadOK(tif, &tif->tif_header, sizeof (TIFFHeader))) { if (tif->tif_mode == O_RDONLY) { TIFFError(name, "Cannot read TIFF header"); goto bad; } /* * Setup header and write. */ tif->tif_header.tiff_magic = tif->tif_flags & TIFF_SWAB ? (bigendian ? TIFF_LITTLEENDIAN : TIFF_BIGENDIAN) : (bigendian ? TIFF_BIGENDIAN : TIFF_LITTLEENDIAN); tif->tif_header.tiff_version = TIFF_VERSION; if (tif->tif_flags & TIFF_SWAB) TIFFSwabShort(&tif->tif_header.tiff_version); tif->tif_header.tiff_diroff = 0; /* filled in later */ if (!WriteOK(tif, &tif->tif_header, sizeof (TIFFHeader))) { TIFFError(name, "Error writing TIFF header"); goto bad; } /* * Setup the byte order handling. */ TIFFInitOrder(tif, tif->tif_header.tiff_magic, bigendian); /* * Setup default directory. */ if (!TIFFDefaultDirectory(tif)) goto bad; tif->tif_diroff = 0; return (tif); } /* * Setup the byte order handling. */ if (tif->tif_header.tiff_magic != TIFF_BIGENDIAN && tif->tif_header.tiff_magic != TIFF_LITTLEENDIAN) { TIFFError(name, "Not a TIFF file, bad magic number %d (0x%x)", tif->tif_header.tiff_magic, tif->tif_header.tiff_magic); goto bad; } TIFFInitOrder(tif, tif->tif_header.tiff_magic, bigendian); /* * Swap header if required. */ if (tif->tif_flags & TIFF_SWAB) { TIFFSwabShort(&tif->tif_header.tiff_version); TIFFSwabLong(&tif->tif_header.tiff_diroff); } /* * Now check version (if needed, it's been byte-swapped). * Note that this isn't actually a version number, it's a * magic number that doesn't change (stupid). */ if (tif->tif_header.tiff_version != TIFF_VERSION) { TIFFError(name, "Not a TIFF file, bad version number %d (0x%x)", tif->tif_header.tiff_version, tif->tif_header.tiff_version); goto bad; } tif->tif_flags |= TIFF_MYBUFFER; tif->tif_rawcp = tif->tif_rawdata = 0; tif->tif_rawdatasize = 0; /* * Setup initial directory. */ switch (mode[0]) { case 'r': tif->tif_nextdiroff = tif->tif_header.tiff_diroff; /* * Try to use a memory-mapped file if the client * has not explicitly suppressed usage with the * 'm' flag in the open mode (see above). */ if ((tif->tif_flags & TIFF_MAPPED) && !TIFFMapFileContents(tif, (tdata_t*) &tif->tif_base, &tif->tif_size)) tif->tif_flags &= ~TIFF_MAPPED; if (TIFFReadDirectory(tif)) { tif->tif_rawcc = -1; tif->tif_flags |= TIFF_BUFFERSETUP; return (tif); } break; case 'a': /* * New directories are automatically append * to the end of the directory chain when they * are written out (see TIFFWriteDirectory). */ if (!TIFFDefaultDirectory(tif)) goto bad; return (tif); } bad: tif->tif_mode = O_RDONLY; /* XXX avoid flush */ TIFFClose(tif); return ((TIFF*)0); bad2: (void) (*closeproc)(clientdata); return ((TIFF*)0); } /* * Query functions to access private data. */ /* * Return open file's name. */ const char * TIFFFileName(TIFF* tif) { return (tif->tif_name); } /* * Return open file's I/O descriptor. */ int TIFFFileno(TIFF* tif) { return (tif->tif_fd); } /* * Return read/write mode. */ int TIFFGetMode(TIFF* tif) { return (tif->tif_mode); } /* * Return nonzero if file is organized in * tiles; zero if organized as strips. */ int TIFFIsTiled(TIFF* tif) { return (isTiled(tif)); } /* * Return current row being read/written. */ uint32 TIFFCurrentRow(TIFF* tif) { return (tif->tif_row); } /* * Return index of the current directory. */ tdir_t TIFFCurrentDirectory(TIFF* tif) { return (tif->tif_curdir); } /* * Return current strip. */ tstrip_t TIFFCurrentStrip(TIFF* tif) { return (tif->tif_curstrip); } /* * Return current tile. */ ttile_t TIFFCurrentTile(TIFF* tif) { return (tif->tif_curtile); } /* * Return nonzero if the file has byte-swapped data. */ int TIFFIsByteSwapped(TIFF* tif) { return ((tif->tif_flags & TIFF_SWAB) != 0); } /* * Return nonzero if the data is returned up-sampled. */ int TIFFIsUpSampled(TIFF* tif) { return (isUpSampled(tif)); } /* * Return nonzero if the data is returned in MSB-to-LSB bit order. */ int TIFFIsMSB2LSB(TIFF* tif) { return (isFillOrder(tif, FILLORDER_MSB2LSB)); } netpbm-8.2/libtiff/tif_packbits.c0100660000076400000000000001455006747424643016140 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_packbits.c,v 1.1.1.1 1999/07/27 21:50:27 mike Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #include "tiffiop.h" #ifdef PACKBITS_SUPPORT /* * TIFF Library. * * PackBits Compression Algorithm Support */ #include #include static int PackBitsPreEncode(TIFF* tif, tsample_t s) { (void) s; /* * Calculate the scanline/tile-width size in bytes. */ if (isTiled(tif)) tif->tif_data = (tidata_t) TIFFTileRowSize(tif); else tif->tif_data = (tidata_t) TIFFScanlineSize(tif); return (1); } /* * NB: tidata is the type representing *(tidata_t); * if tidata_t is made signed then this type must * be adjusted accordingly. */ typedef unsigned char tidata; /* * Encode a run of pixels. */ static int PackBitsEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s) { u_char* bp = (u_char*) buf; tidata_t op, ep, lastliteral; long n, slop; int b; enum { BASE, LITERAL, RUN, LITERAL_RUN } state; (void) s; op = tif->tif_rawcp; ep = tif->tif_rawdata + tif->tif_rawdatasize; state = BASE; lastliteral = 0; while (cc > 0) { /* * Find the longest string of identical bytes. */ b = *bp++, cc--, n = 1; for (; cc > 0 && b == *bp; cc--, bp++) n++; again: if (op + 2 >= ep) { /* insure space for new data */ /* * Be careful about writing the last * literal. Must write up to that point * and then copy the remainder to the * front of the buffer. */ if (state == LITERAL || state == LITERAL_RUN) { slop = op - lastliteral; tif->tif_rawcc += lastliteral - tif->tif_rawcp; if (!TIFFFlushData1(tif)) return (-1); op = tif->tif_rawcp; while (slop-- > 0) *op++ = *lastliteral++; lastliteral = tif->tif_rawcp; } else { tif->tif_rawcc += op - tif->tif_rawcp; if (!TIFFFlushData1(tif)) return (-1); op = tif->tif_rawcp; } } switch (state) { case BASE: /* initial state, set run/literal */ if (n > 1) { state = RUN; if (n > 128) { *op++ = (tidata) -127; *op++ = b; n -= 128; goto again; } *op++ = (tidataval_t)(-(n-1)); *op++ = b; } else { lastliteral = op; *op++ = 0; *op++ = b; state = LITERAL; } break; case LITERAL: /* last object was literal string */ if (n > 1) { state = LITERAL_RUN; if (n > 128) { *op++ = (tidata) -127; *op++ = b; n -= 128; goto again; } *op++ = (tidataval_t)(-(n-1)); /* encode run */ *op++ = b; } else { /* extend literal */ if (++(*lastliteral) == 127) state = BASE; *op++ = b; } break; case RUN: /* last object was run */ if (n > 1) { if (n > 128) { *op++ = (tidata) -127; *op++ = b; n -= 128; goto again; } *op++ = (tidataval_t)(-(n-1)); *op++ = b; } else { lastliteral = op; *op++ = 0; *op++ = b; state = LITERAL; } break; case LITERAL_RUN: /* literal followed by a run */ /* * Check to see if previous run should * be converted to a literal, in which * case we convert literal-run-literal * to a single literal. */ if (n == 1 && op[-2] == (tidata) -1 && *lastliteral < 126) { state = (((*lastliteral) += 2) == 127 ? BASE : LITERAL); op[-2] = op[-1]; /* replicate */ } else state = RUN; goto again; } } tif->tif_rawcc += op - tif->tif_rawcp; tif->tif_rawcp = op; return (1); } /* * Encode a rectangular chunk of pixels. We break it up * into row-sized pieces to insure that encoded runs do * not span rows. Otherwise, there can be problems with * the decoder if data is read, for example, by scanlines * when it was encoded by strips. */ static int PackBitsEncodeChunk(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) { tsize_t rowsize = (tsize_t) tif->tif_data; assert(rowsize > 0); while ((long)cc > 0) { if (PackBitsEncode(tif, bp, rowsize, s) < 0) return (-1); bp += rowsize; cc -= rowsize; } return (1); } static int PackBitsDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) { char *bp; tsize_t cc; long n; int b; (void) s; bp = (char*) tif->tif_rawcp; cc = tif->tif_rawcc; while (cc > 0 && (long)occ > 0) { n = (long) *bp++, cc--; /* * Watch out for compilers that * don't sign extend chars... */ if (n >= 128) n -= 256; if (n < 0) { /* replicate next byte -n+1 times */ if (n == -128) /* nop */ continue; n = -n + 1; occ -= n; b = *bp++, cc--; while (n-- > 0) *op++ = b; } else { /* copy next n+1 bytes literally */ _TIFFmemcpy(op, bp, ++n); op += n; occ -= n; bp += n; cc -= n; } } tif->tif_rawcp = (tidata_t) bp; tif->tif_rawcc = cc; if (occ > 0) { TIFFError(tif->tif_name, "PackBitsDecode: Not enough data for scanline %ld", (long) tif->tif_row); return (0); } /* check for buffer overruns? */ return (1); } int TIFFInitPackBits(TIFF* tif, int scheme) { (void) scheme; tif->tif_decoderow = PackBitsDecode; tif->tif_decodestrip = PackBitsDecode; tif->tif_decodetile = PackBitsDecode; tif->tif_preencode = PackBitsPreEncode; tif->tif_encoderow = PackBitsEncode; tif->tif_encodestrip = PackBitsEncodeChunk; tif->tif_encodetile = PackBitsEncodeChunk; return (1); } #endif /* PACKBITS_SUPPORT */ netpbm-8.2/libtiff/tif_pixarlog.c0100660000076400000000000010622006747424643016161 0ustar bryanhroot/* * Copyright (c) 1996-1997 Sam Leffler * Copyright (c) 1996 Pixar * * 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 * Pixar, 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 Pixar, 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 PIXAR, 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. */ #include "tiffiop.h" #ifdef PIXARLOG_SUPPORT /* * TIFF Library. * PixarLog Compression Support * * Contributed by Dan McCoy. * * PixarLog film support uses the TIFF library to store companded * 11 bit values into a tiff file, which are compressed using the * zip compressor. * * The codec can take as input and produce as output 32-bit IEEE float values * as well as 16-bit or 8-bit unsigned integer values. * * On writing any of the above are converted into the internal * 11-bit log format. In the case of 8 and 16 bit values, the * input is assumed to be unsigned linear color values that represent * the range 0-1. In the case of IEEE values, the 0-1 range is assumed to * be the normal linear color range, in addition over 1 values are * accepted up to a value of about 25.0 to encode "hot" hightlights and such. * The encoding is lossless for 8-bit values, slightly lossy for the * other bit depths. The actual color precision should be better * than the human eye can perceive with extra room to allow for * error introduced by further image computation. As with any quantized * color format, it is possible to perform image calculations which * expose the quantization error. This format should certainly be less * susceptable to such errors than standard 8-bit encodings, but more * susceptable than straight 16-bit or 32-bit encodings. * * On reading the internal format is converted to the desired output format. * The program can request which format it desires by setting the internal * pseudo tag TIFFTAG_PIXARLOGDATAFMT to one of these possible values: * PIXARLOGDATAFMT_FLOAT = provide IEEE float values. * PIXARLOGDATAFMT_16BIT = provide unsigned 16-bit integer values * PIXARLOGDATAFMT_8BIT = provide unsigned 8-bit integer values * * alternately PIXARLOGDATAFMT_8BITABGR provides unsigned 8-bit integer * values with the difference that if there are exactly three or four channels * (rgb or rgba) it swaps the channel order (bgr or abgr). * * PIXARLOGDATAFMT_11BITLOG provides the internal encoding directly * packed in 16-bit values. However no tools are supplied for interpreting * these values. * * "hot" (over 1.0) areas written in floating point get clamped to * 1.0 in the integer data types. * * When the file is closed after writing, the bit depth and sample format * are set always to appear as if 8-bit data has been written into it. * That way a naive program unaware of the particulars of the encoding * gets the format it is most likely able to handle. * * The codec does it's own horizontal differencing step on the coded * values so the libraries predictor stuff should be turned off. * The codec also handle byte swapping the encoded values as necessary * since the library does not have the information necessary * to know the bit depth of the raw unencoded buffer. * */ #include "tif_predict.h" #include "zlib.h" #include "zutil.h" #include #include #include #include /* Tables for converting to/from 11 bit coded values */ #define TSIZE 2048 /* decode table size (11-bit tokens) */ #define TSIZEP1 2049 /* Plus one for slop */ #define ONE 1250 /* token value of 1.0 exactly */ #define RATIO 1.004 /* nominal ratio for log part */ #define CODE_MASK 0x7ff /* 11 bits. */ static float Fltsize; static float LogK1, LogK2; #define REPEAT(n, op) { int i; i=n; do { i--; op; } while (i>0); } static void horizontalAccumulateF(uint16 *wp, int n, int stride, float *op, float *ToLinearF) { register unsigned int cr, cg, cb, ca, mask; register float t0, t1, t2, t3; if (n >= stride) { mask = CODE_MASK; if (stride == 3) { t0 = ToLinearF[cr = wp[0]]; t1 = ToLinearF[cg = wp[1]]; t2 = ToLinearF[cb = wp[2]]; op[0] = t0; op[1] = t1; op[2] = t2; n -= 3; while (n > 0) { wp += 3; op += 3; n -= 3; t0 = ToLinearF[(cr += wp[0]) & mask]; t1 = ToLinearF[(cg += wp[1]) & mask]; t2 = ToLinearF[(cb += wp[2]) & mask]; op[0] = t0; op[1] = t1; op[2] = t2; } } else if (stride == 4) { t0 = ToLinearF[cr = wp[0]]; t1 = ToLinearF[cg = wp[1]]; t2 = ToLinearF[cb = wp[2]]; t3 = ToLinearF[ca = wp[3]]; op[0] = t0; op[1] = t1; op[2] = t2; op[3] = t3; n -= 4; while (n > 0) { wp += 4; op += 4; n -= 4; t0 = ToLinearF[(cr += wp[0]) & mask]; t1 = ToLinearF[(cg += wp[1]) & mask]; t2 = ToLinearF[(cb += wp[2]) & mask]; t3 = ToLinearF[(ca += wp[3]) & mask]; op[0] = t0; op[1] = t1; op[2] = t2; op[3] = t3; } } else { REPEAT(stride, *op = ToLinearF[*wp&mask]; wp++; op++) n -= stride; while (n > 0) { REPEAT(stride, wp[stride] += *wp; *op = ToLinearF[*wp&mask]; wp++; op++) n -= stride; } } } } static void horizontalAccumulate12(uint16 *wp, int n, int stride, int16 *op, float *ToLinearF) { register unsigned int cr, cg, cb, ca, mask; register float t0, t1, t2, t3; #define SCALE12 2048.0 #define CLAMP12(t) (((t) < 3071) ? (uint16) (t) : 3071) if (n >= stride) { mask = CODE_MASK; if (stride == 3) { t0 = ToLinearF[cr = wp[0]] * SCALE12; t1 = ToLinearF[cg = wp[1]] * SCALE12; t2 = ToLinearF[cb = wp[2]] * SCALE12; op[0] = CLAMP12(t0); op[1] = CLAMP12(t1); op[2] = CLAMP12(t2); n -= 3; while (n > 0) { wp += 3; op += 3; n -= 3; t0 = ToLinearF[(cr += wp[0]) & mask] * SCALE12; t1 = ToLinearF[(cg += wp[1]) & mask] * SCALE12; t2 = ToLinearF[(cb += wp[2]) & mask] * SCALE12; op[0] = CLAMP12(t0); op[1] = CLAMP12(t1); op[2] = CLAMP12(t2); } } else if (stride == 4) { t0 = ToLinearF[cr = wp[0]] * SCALE12; t1 = ToLinearF[cg = wp[1]] * SCALE12; t2 = ToLinearF[cb = wp[2]] * SCALE12; t3 = ToLinearF[ca = wp[3]] * SCALE12; op[0] = CLAMP12(t0); op[1] = CLAMP12(t1); op[2] = CLAMP12(t2); op[3] = CLAMP12(t3); n -= 4; while (n > 0) { wp += 4; op += 4; n -= 4; t0 = ToLinearF[(cr += wp[0]) & mask] * SCALE12; t1 = ToLinearF[(cg += wp[1]) & mask] * SCALE12; t2 = ToLinearF[(cb += wp[2]) & mask] * SCALE12; t3 = ToLinearF[(ca += wp[3]) & mask] * SCALE12; op[0] = CLAMP12(t0); op[1] = CLAMP12(t1); op[2] = CLAMP12(t2); op[3] = CLAMP12(t3); } } else { REPEAT(stride, t0 = ToLinearF[*wp&mask] * SCALE12; *op = CLAMP12(t0); wp++; op++) n -= stride; while (n > 0) { REPEAT(stride, wp[stride] += *wp; t0 = ToLinearF[wp[stride]&mask]*SCALE12; *op = CLAMP12(t0); wp++; op++) n -= stride; } } } } static void horizontalAccumulate16(uint16 *wp, int n, int stride, uint16 *op, uint16 *ToLinear16) { register unsigned int cr, cg, cb, ca, mask; if (n >= stride) { mask = CODE_MASK; if (stride == 3) { op[0] = ToLinear16[cr = wp[0]]; op[1] = ToLinear16[cg = wp[1]]; op[2] = ToLinear16[cb = wp[2]]; n -= 3; while (n > 0) { wp += 3; op += 3; n -= 3; op[0] = ToLinear16[(cr += wp[0]) & mask]; op[1] = ToLinear16[(cg += wp[1]) & mask]; op[2] = ToLinear16[(cb += wp[2]) & mask]; } } else if (stride == 4) { op[0] = ToLinear16[cr = wp[0]]; op[1] = ToLinear16[cg = wp[1]]; op[2] = ToLinear16[cb = wp[2]]; op[3] = ToLinear16[ca = wp[3]]; n -= 4; while (n > 0) { wp += 4; op += 4; n -= 4; op[0] = ToLinear16[(cr += wp[0]) & mask]; op[1] = ToLinear16[(cg += wp[1]) & mask]; op[2] = ToLinear16[(cb += wp[2]) & mask]; op[3] = ToLinear16[(ca += wp[3]) & mask]; } } else { REPEAT(stride, *op = ToLinear16[*wp&mask]; wp++; op++) n -= stride; while (n > 0) { REPEAT(stride, wp[stride] += *wp; *op = ToLinear16[*wp&mask]; wp++; op++) n -= stride; } } } } /* * Returns the log encoded 11-bit values with the horizontal * differencing undone. */ static void horizontalAccumulate11(uint16 *wp, int n, int stride, uint16 *op) { register unsigned int cr, cg, cb, ca, mask; if (n >= stride) { mask = CODE_MASK; if (stride == 3) { op[0] = cr = wp[0]; op[1] = cg = wp[1]; op[2] = cb = wp[2]; n -= 3; while (n > 0) { wp += 3; op += 3; n -= 3; op[0] = (cr += wp[0]) & mask; op[1] = (cg += wp[1]) & mask; op[2] = (cb += wp[2]) & mask; } } else if (stride == 4) { op[0] = cr = wp[0]; op[1] = cg = wp[1]; op[2] = cb = wp[2]; op[3] = ca = wp[3]; n -= 4; while (n > 0) { wp += 4; op += 4; n -= 4; op[0] = (cr += wp[0]) & mask; op[1] = (cg += wp[1]) & mask; op[2] = (cb += wp[2]) & mask; op[3] = (ca += wp[3]) & mask; } } else { REPEAT(stride, *op = *wp&mask; wp++; op++) n -= stride; while (n > 0) { REPEAT(stride, wp[stride] += *wp; *op = *wp&mask; wp++; op++) n -= stride; } } } } static void horizontalAccumulate8(uint16 *wp, int n, int stride, unsigned char *op, unsigned char *ToLinear8) { register unsigned int cr, cg, cb, ca, mask; if (n >= stride) { mask = CODE_MASK; if (stride == 3) { op[0] = ToLinear8[cr = wp[0]]; op[1] = ToLinear8[cg = wp[1]]; op[2] = ToLinear8[cb = wp[2]]; n -= 3; while (n > 0) { n -= 3; wp += 3; op += 3; op[0] = ToLinear8[(cr += wp[0]) & mask]; op[1] = ToLinear8[(cg += wp[1]) & mask]; op[2] = ToLinear8[(cb += wp[2]) & mask]; } } else if (stride == 4) { op[0] = ToLinear8[cr = wp[0]]; op[1] = ToLinear8[cg = wp[1]]; op[2] = ToLinear8[cb = wp[2]]; op[3] = ToLinear8[ca = wp[3]]; n -= 4; while (n > 0) { n -= 4; wp += 4; op += 4; op[0] = ToLinear8[(cr += wp[0]) & mask]; op[1] = ToLinear8[(cg += wp[1]) & mask]; op[2] = ToLinear8[(cb += wp[2]) & mask]; op[3] = ToLinear8[(ca += wp[3]) & mask]; } } else { REPEAT(stride, *op = ToLinear8[*wp&mask]; wp++; op++) n -= stride; while (n > 0) { REPEAT(stride, wp[stride] += *wp; *op = ToLinear8[*wp&mask]; wp++; op++) n -= stride; } } } } static void horizontalAccumulate8abgr(uint16 *wp, int n, int stride, unsigned char *op, unsigned char *ToLinear8) { register unsigned int cr, cg, cb, ca, mask; register unsigned char t0, t1, t2, t3; if (n >= stride) { mask = CODE_MASK; if (stride == 3) { op[0] = 0; t1 = ToLinear8[cb = wp[2]]; t2 = ToLinear8[cg = wp[1]]; t3 = ToLinear8[cr = wp[0]]; op[1] = t1; op[2] = t2; op[3] = t3; n -= 3; while (n > 0) { n -= 3; wp += 3; op += 4; op[0] = 0; t1 = ToLinear8[(cb += wp[2]) & mask]; t2 = ToLinear8[(cg += wp[1]) & mask]; t3 = ToLinear8[(cr += wp[0]) & mask]; op[1] = t1; op[2] = t2; op[3] = t3; } } else if (stride == 4) { t0 = ToLinear8[ca = wp[3]]; t1 = ToLinear8[cb = wp[2]]; t2 = ToLinear8[cg = wp[1]]; t3 = ToLinear8[cr = wp[0]]; op[0] = t0; op[1] = t1; op[2] = t2; op[3] = t3; n -= 4; while (n > 0) { n -= 4; wp += 4; op += 4; t0 = ToLinear8[(ca += wp[3]) & mask]; t1 = ToLinear8[(cb += wp[2]) & mask]; t2 = ToLinear8[(cg += wp[1]) & mask]; t3 = ToLinear8[(cr += wp[0]) & mask]; op[0] = t0; op[1] = t1; op[2] = t2; op[3] = t3; } } else { REPEAT(stride, *op = ToLinear8[*wp&mask]; wp++; op++) n -= stride; while (n > 0) { REPEAT(stride, wp[stride] += *wp; *op = ToLinear8[*wp&mask]; wp++; op++) n -= stride; } } } } /* * State block for each open TIFF * file using PixarLog compression/decompression. */ typedef struct { TIFFPredictorState predict; z_stream stream; uint16 *tbuf; uint16 stride; int state; int user_datafmt; int quality; #define PLSTATE_INIT 1 TIFFVSetMethod vgetparent; /* super-class method */ TIFFVSetMethod vsetparent; /* super-class method */ float *ToLinearF; uint16 *ToLinear16; unsigned char *ToLinear8; uint16 *FromLT2; uint16 *From14; /* Really for 16-bit data, but we shift down 2 */ uint16 *From8; } PixarLogState; static int PixarLogMakeTables(PixarLogState *sp) { /* * We make several tables here to convert between various external * representations (float, 16-bit, and 8-bit) and the internal * 11-bit companded representation. The 11-bit representation has two * distinct regions. A linear bottom end up through .018316 in steps * of about .000073, and a region of constant ratio up to about 25. * These floating point numbers are stored in the main table ToLinearF. * All other tables are derived from this one. The tables (and the * ratios) are continuous at the internal seam. */ int nlin, lt2size; int i, j; double b, c, linstep, max; double k, v, dv, r, lr2, r2; float *ToLinearF; uint16 *ToLinear16; unsigned char *ToLinear8; uint16 *FromLT2; uint16 *From14; /* Really for 16-bit data, but we shift down 2 */ uint16 *From8; c = log(RATIO); nlin = 1./c; /* nlin must be an integer */ c = 1./nlin; b = exp(-c*ONE); /* multiplicative scale factor [b*exp(c*ONE) = 1] */ linstep = b*c*exp(1.); LogK1 = 1./c; /* if (v >= 2) token = k1*log(v*k2) */ LogK2 = 1./b; lt2size = (2./linstep)+1; FromLT2 = (uint16 *)_TIFFmalloc(lt2size*sizeof(uint16)); From14 = (uint16 *)_TIFFmalloc(16384*sizeof(uint16)); From8 = (uint16 *)_TIFFmalloc(256*sizeof(uint16)); ToLinearF = (float *)_TIFFmalloc(TSIZEP1 * sizeof(float)); ToLinear16 = (uint16 *)_TIFFmalloc(TSIZEP1 * sizeof(uint16)); ToLinear8 = (unsigned char *)_TIFFmalloc(TSIZEP1 * sizeof(unsigned char)); if (FromLT2 == NULL || From14 == NULL || From8 == NULL || ToLinearF == NULL || ToLinear16 == NULL || ToLinear8 == NULL) { if (FromLT2) _TIFFfree(FromLT2); if (From14) _TIFFfree(From14); if (From8) _TIFFfree(From8); if (ToLinearF) _TIFFfree(ToLinearF); if (ToLinear16) _TIFFfree(ToLinear16); if (ToLinear8) _TIFFfree(ToLinear8); sp->FromLT2 = NULL; sp->From14 = NULL; sp->From8 = NULL; sp->ToLinearF = NULL; sp->ToLinear16 = NULL; sp->ToLinear8 = NULL; return 0; } j = 0; for (i = 0; i < nlin; i++) { v = i * linstep; ToLinearF[j++] = v; } for (i = nlin; i < TSIZE; i++) ToLinearF[j++] = b*exp(c*i); ToLinearF[2048] = ToLinearF[2047]; for (i = 0; i < TSIZEP1; i++) { v = ToLinearF[i]*65535.0 + 0.5; ToLinear16[i] = (v > 65535.0) ? 65535 : v; v = ToLinearF[i]*255.0 + 0.5; ToLinear8[i] = (v > 255.0) ? 255 : v; } j = 0; for (i = 0; i < lt2size; i++) { if ((i*linstep)*(i*linstep) > ToLinearF[j]*ToLinearF[j+1]) j++; FromLT2[i] = j; } /* * Since we lose info anyway on 16-bit data, we set up a 14-bit * table and shift 16-bit values down two bits on input. * saves a little table space. */ j = 0; for (i = 0; i < 16384; i++) { while ((i/16383.)*(i/16383.) > ToLinearF[j]*ToLinearF[j+1]) j++; From14[i] = j; } j = 0; for (i = 0; i < 256; i++) { while ((i/255.)*(i/255.) > ToLinearF[j]*ToLinearF[j+1]) j++; From8[i] = j; } Fltsize = lt2size/2; sp->ToLinearF = ToLinearF; sp->ToLinear16 = ToLinear16; sp->ToLinear8 = ToLinear8; sp->FromLT2 = FromLT2; sp->From14 = From14; sp->From8 = From8; return 1; } #define DecoderState(tif) ((PixarLogState*) (tif)->tif_data) #define EncoderState(tif) ((PixarLogState*) (tif)->tif_data) static int PixarLogEncode(TIFF*, tidata_t, tsize_t, tsample_t); static int PixarLogDecode(TIFF*, tidata_t, tsize_t, tsample_t); #define N(a) (sizeof(a)/sizeof(a[0])) #define PIXARLOGDATAFMT_UNKNOWN -1 static int PixarLogGuessDataFmt(TIFFDirectory *td) { int guess = PIXARLOGDATAFMT_UNKNOWN; int format = td->td_sampleformat; /* If the user didn't tell us his datafmt, * take our best guess from the bitspersample. */ switch (td->td_bitspersample) { case 32: if (format == SAMPLEFORMAT_IEEEFP) guess = PIXARLOGDATAFMT_FLOAT; break; case 16: if (format == SAMPLEFORMAT_VOID || format == SAMPLEFORMAT_UINT) guess = PIXARLOGDATAFMT_16BIT; break; case 12: if (format == SAMPLEFORMAT_VOID || format == SAMPLEFORMAT_INT) guess = PIXARLOGDATAFMT_12BITPICIO; break; case 11: if (format == SAMPLEFORMAT_VOID || format == SAMPLEFORMAT_UINT) guess = PIXARLOGDATAFMT_11BITLOG; break; case 8: if (format == SAMPLEFORMAT_VOID || format == SAMPLEFORMAT_UINT) guess = PIXARLOGDATAFMT_8BIT; break; } return guess; } static int PixarLogSetupDecode(TIFF* tif) { TIFFDirectory *td = &tif->tif_dir; PixarLogState* sp = DecoderState(tif); static const char module[] = "PixarLogSetupDecode"; assert(sp != NULL); /* Make sure no byte swapping happens on the data * after decompression. */ tif->tif_postdecode = _TIFFNoPostDecode; /* for some reason, we can't do this in TIFFInitPixarLog */ sp->stride = (td->td_planarconfig == PLANARCONFIG_CONTIG ? td->td_samplesperpixel : 1); sp->tbuf = (uint16 *) _TIFFmalloc(sp->stride * td->td_imagewidth * td->td_rowsperstrip * sizeof(uint16)); if (sp->user_datafmt == PIXARLOGDATAFMT_UNKNOWN) sp->user_datafmt = PixarLogGuessDataFmt(td); if (sp->user_datafmt == PIXARLOGDATAFMT_UNKNOWN) { TIFFError(module, "PixarLog compression can't handle bits depth/data format combination (depth: %d)", td->td_bitspersample); return (0); } if (inflateInit(&sp->stream) != Z_OK) { TIFFError(module, "%s: %s", tif->tif_name, sp->stream.msg); return (0); } else { sp->state |= PLSTATE_INIT; return (1); } } /* * Setup state for decoding a strip. */ static int PixarLogPreDecode(TIFF* tif, tsample_t s) { TIFFDirectory *td = &tif->tif_dir; PixarLogState* sp = DecoderState(tif); (void) s; assert(sp != NULL); sp->stream.next_in = tif->tif_rawdata; sp->stream.avail_in = tif->tif_rawcc; return (inflateReset(&sp->stream) == Z_OK); } static int PixarLogDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) { TIFFDirectory *td = &tif->tif_dir; PixarLogState* sp = DecoderState(tif); static const char module[] = "PixarLogDecode"; int i, nsamples, llen; uint16 *up; switch (sp->user_datafmt) { case PIXARLOGDATAFMT_FLOAT: nsamples = occ / sizeof(float); /* XXX float == 32 bits */ break; case PIXARLOGDATAFMT_16BIT: case PIXARLOGDATAFMT_12BITPICIO: case PIXARLOGDATAFMT_11BITLOG: nsamples = occ / sizeof(uint16); /* XXX uint16 == 16 bits */ break; case PIXARLOGDATAFMT_8BIT: case PIXARLOGDATAFMT_8BITABGR: nsamples = occ; break; default: TIFFError(tif->tif_name, "%d bit input not supported in PixarLog", td->td_bitspersample); return 0; } llen = sp->stride * td->td_imagewidth; (void) s; assert(sp != NULL); sp->stream.next_out = (unsigned char *) sp->tbuf; sp->stream.avail_out = nsamples * sizeof(uint16); do { int state = inflate(&sp->stream, Z_PARTIAL_FLUSH); if (state == Z_STREAM_END) { break; /* XXX */ } if (state == Z_DATA_ERROR) { TIFFError(module, "%s: Decoding error at scanline %d, %s", tif->tif_name, tif->tif_row, sp->stream.msg); if (inflateSync(&sp->stream) != Z_OK) return (0); continue; } if (state != Z_OK) { TIFFError(module, "%s: zlib error: %s", tif->tif_name, sp->stream.msg); return (0); } } while (sp->stream.avail_out > 0); /* hopefully, we got all the bytes we needed */ if (sp->stream.avail_out != 0) { TIFFError(module, "%s: Not enough data at scanline %d (short %d bytes)", tif->tif_name, tif->tif_row, sp->stream.avail_out); return (0); } up = sp->tbuf; /* Swap bytes in the data if from a different endian machine. */ if (tif->tif_flags & TIFF_SWAB) TIFFSwabArrayOfShort(up, nsamples); for (i = 0; i < nsamples; i += llen, up += llen) { switch (sp->user_datafmt) { case PIXARLOGDATAFMT_FLOAT: horizontalAccumulateF(up, llen, sp->stride, (float *)op, sp->ToLinearF); op += llen * sizeof(float); break; case PIXARLOGDATAFMT_16BIT: horizontalAccumulate16(up, llen, sp->stride, (uint16 *)op, sp->ToLinear16); op += llen * sizeof(uint16); break; case PIXARLOGDATAFMT_12BITPICIO: horizontalAccumulate12(up, llen, sp->stride, (int16 *)op, sp->ToLinearF); op += llen * sizeof(int16); break; case PIXARLOGDATAFMT_11BITLOG: horizontalAccumulate11(up, llen, sp->stride, (uint16 *)op); op += llen * sizeof(uint16); break; case PIXARLOGDATAFMT_8BIT: horizontalAccumulate8(up, llen, sp->stride, (unsigned char *)op, sp->ToLinear8); op += llen * sizeof(unsigned char); break; case PIXARLOGDATAFMT_8BITABGR: horizontalAccumulate8abgr(up, llen, sp->stride, (unsigned char *)op, sp->ToLinear8); op += llen * sizeof(unsigned char); break; default: TIFFError(tif->tif_name, "PixarLogDecode: unsupported bits/sample: %d", td->td_bitspersample); return (0); } } return (1); } static int PixarLogSetupEncode(TIFF* tif) { TIFFDirectory *td = &tif->tif_dir; PixarLogState* sp = EncoderState(tif); static const char module[] = "PixarLogSetupEncode"; assert(sp != NULL); /* for some reason, we can't do this in TIFFInitPixarLog */ sp->stride = (td->td_planarconfig == PLANARCONFIG_CONTIG ? td->td_samplesperpixel : 1); sp->tbuf = (uint16 *) _TIFFmalloc(sp->stride * td->td_imagewidth * td->td_rowsperstrip * sizeof(uint16)); if (sp->user_datafmt == PIXARLOGDATAFMT_UNKNOWN) sp->user_datafmt = PixarLogGuessDataFmt(td); if (sp->user_datafmt == PIXARLOGDATAFMT_UNKNOWN) { TIFFError(module, "PixarLog compression can't handle %d bit linear encodings", td->td_bitspersample); return (0); } if (deflateInit(&sp->stream, sp->quality) != Z_OK) { TIFFError(module, "%s: %s", tif->tif_name, sp->stream.msg); return (0); } else { sp->state |= PLSTATE_INIT; return (1); } } /* * Reset encoding state at the start of a strip. */ static int PixarLogPreEncode(TIFF* tif, tsample_t s) { TIFFDirectory *td = &tif->tif_dir; PixarLogState *sp = EncoderState(tif); (void) s; assert(sp != NULL); sp->stream.next_out = tif->tif_rawdata; sp->stream.avail_out = tif->tif_rawdatasize; return (deflateReset(&sp->stream) == Z_OK); } static void horizontalDifferenceF(float *ip, int n, int stride, uint16 *wp, uint16 *FromLT2) { register int r1, g1, b1, a1, r2, g2, b2, a2, mask; register float fltsize = Fltsize; #define CLAMP(v) ( (v<(float)0.) ? 0 \ : (v<(float)2.) ? FromLT2[(int)(v*fltsize)] \ : (v>(float)24.2) ? 2047 \ : LogK1*log(v*LogK2) + 0.5 ) mask = CODE_MASK; if (n >= stride) { if (stride == 3) { r2 = wp[0] = CLAMP(ip[0]); g2 = wp[1] = CLAMP(ip[1]); b2 = wp[2] = CLAMP(ip[2]); n -= 3; while (n > 0) { n -= 3; wp += 3; ip += 3; r1 = CLAMP(ip[0]); wp[0] = (r1-r2) & mask; r2 = r1; g1 = CLAMP(ip[1]); wp[1] = (g1-g2) & mask; g2 = g1; b1 = CLAMP(ip[2]); wp[2] = (b1-b2) & mask; b2 = b1; } } else if (stride == 4) { r2 = wp[0] = CLAMP(ip[0]); g2 = wp[1] = CLAMP(ip[1]); b2 = wp[2] = CLAMP(ip[2]); a2 = wp[3] = CLAMP(ip[3]); n -= 4; while (n > 0) { n -= 4; wp += 4; ip += 4; r1 = CLAMP(ip[0]); wp[0] = (r1-r2) & mask; r2 = r1; g1 = CLAMP(ip[1]); wp[1] = (g1-g2) & mask; g2 = g1; b1 = CLAMP(ip[2]); wp[2] = (b1-b2) & mask; b2 = b1; a1 = CLAMP(ip[3]); wp[3] = (a1-a2) & mask; a2 = a1; } } else { ip += n - 1; /* point to last one */ wp += n - 1; /* point to last one */ n -= stride; while (n > 0) { REPEAT(stride, wp[0] = CLAMP(ip[0]); wp[stride] -= wp[0]; wp[stride] &= mask; wp--; ip--) n -= stride; } REPEAT(stride, wp[0] = CLAMP(ip[0]); wp--; ip--) } } } static void horizontalDifference16(unsigned short *ip, int n, int stride, unsigned short *wp, uint16 *From14) { register int r1, g1, b1, a1, r2, g2, b2, a2, mask; /* assumption is unsigned pixel values */ #undef CLAMP #define CLAMP(v) From14[(v) >> 2] mask = CODE_MASK; if (n >= stride) { if (stride == 3) { r2 = wp[0] = CLAMP(ip[0]); g2 = wp[1] = CLAMP(ip[1]); b2 = wp[2] = CLAMP(ip[2]); n -= 3; while (n > 0) { n -= 3; wp += 3; ip += 3; r1 = CLAMP(ip[0]); wp[0] = (r1-r2) & mask; r2 = r1; g1 = CLAMP(ip[1]); wp[1] = (g1-g2) & mask; g2 = g1; b1 = CLAMP(ip[2]); wp[2] = (b1-b2) & mask; b2 = b1; } } else if (stride == 4) { r2 = wp[0] = CLAMP(ip[0]); g2 = wp[1] = CLAMP(ip[1]); b2 = wp[2] = CLAMP(ip[2]); a2 = wp[3] = CLAMP(ip[3]); n -= 4; while (n > 0) { n -= 4; wp += 4; ip += 4; r1 = CLAMP(ip[0]); wp[0] = (r1-r2) & mask; r2 = r1; g1 = CLAMP(ip[1]); wp[1] = (g1-g2) & mask; g2 = g1; b1 = CLAMP(ip[2]); wp[2] = (b1-b2) & mask; b2 = b1; a1 = CLAMP(ip[3]); wp[3] = (a1-a2) & mask; a2 = a1; } } else { ip += n - 1; /* point to last one */ wp += n - 1; /* point to last one */ n -= stride; while (n > 0) { REPEAT(stride, wp[0] = CLAMP(ip[0]); wp[stride] -= wp[0]; wp[stride] &= mask; wp--; ip--) n -= stride; } REPEAT(stride, wp[0] = CLAMP(ip[0]); wp--; ip--) } } } static void horizontalDifference8(unsigned char *ip, int n, int stride, unsigned short *wp, uint16 *From8) { register int r1, g1, b1, a1, r2, g2, b2, a2, mask; #undef CLAMP #define CLAMP(v) (From8[(v)]) mask = CODE_MASK; if (n >= stride) { if (stride == 3) { r2 = wp[0] = CLAMP(ip[0]); g2 = wp[1] = CLAMP(ip[1]); b2 = wp[2] = CLAMP(ip[2]); n -= 3; while (n > 0) { n -= 3; r1 = CLAMP(ip[3]); wp[3] = (r1-r2) & mask; r2 = r1; g1 = CLAMP(ip[4]); wp[4] = (g1-g2) & mask; g2 = g1; b1 = CLAMP(ip[5]); wp[5] = (b1-b2) & mask; b2 = b1; wp += 3; ip += 3; } } else if (stride == 4) { r2 = wp[0] = CLAMP(ip[0]); g2 = wp[1] = CLAMP(ip[1]); b2 = wp[2] = CLAMP(ip[2]); a2 = wp[3] = CLAMP(ip[3]); n -= 4; while (n > 0) { n -= 4; r1 = CLAMP(ip[4]); wp[4] = (r1-r2) & mask; r2 = r1; g1 = CLAMP(ip[5]); wp[5] = (g1-g2) & mask; g2 = g1; b1 = CLAMP(ip[6]); wp[6] = (b1-b2) & mask; b2 = b1; a1 = CLAMP(ip[7]); wp[7] = (a1-a2) & mask; a2 = a1; wp += 4; ip += 4; } } else { wp += n + stride - 1; /* point to last one */ ip += n + stride - 1; /* point to last one */ n -= stride; while (n > 0) { REPEAT(stride, wp[0] = CLAMP(ip[0]); wp[stride] -= wp[0]; wp[stride] &= mask; wp--; ip--) n -= stride; } REPEAT(stride, wp[0] = CLAMP(ip[0]); wp--; ip--) } } } /* * Encode a chunk of pixels. */ static int PixarLogEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) { TIFFDirectory *td = &tif->tif_dir; PixarLogState *sp = EncoderState(tif); static const char module[] = "PixarLogEncode"; int i, n, llen; unsigned short * up; (void) s; switch (sp->user_datafmt) { case PIXARLOGDATAFMT_FLOAT: n = cc / sizeof(float); /* XXX float == 32 bits */ break; case PIXARLOGDATAFMT_16BIT: case PIXARLOGDATAFMT_12BITPICIO: case PIXARLOGDATAFMT_11BITLOG: n = cc / sizeof(uint16); /* XXX uint16 == 16 bits */ break; case PIXARLOGDATAFMT_8BIT: case PIXARLOGDATAFMT_8BITABGR: n = cc; break; default: TIFFError(tif->tif_name, "%d bit input not supported in PixarLog", td->td_bitspersample); return 0; } llen = sp->stride * td->td_imagewidth; for (i = 0, up = sp->tbuf; i < n; i += llen, up += llen) { switch (sp->user_datafmt) { case PIXARLOGDATAFMT_FLOAT: horizontalDifferenceF((float *)bp, llen, sp->stride, up, sp->FromLT2); bp += llen * sizeof(float); break; case PIXARLOGDATAFMT_16BIT: horizontalDifference16((uint16 *)bp, llen, sp->stride, up, sp->From14); bp += llen * sizeof(uint16); break; case PIXARLOGDATAFMT_8BIT: horizontalDifference8((unsigned char *)bp, llen, sp->stride, up, sp->From8); bp += llen * sizeof(unsigned char); break; default: TIFFError(tif->tif_name, "%d bit input not supported in PixarLog", td->td_bitspersample); return 0; } } sp->stream.next_in = (unsigned char *) sp->tbuf; sp->stream.avail_in = n * sizeof(uint16); do { if (deflate(&sp->stream, Z_NO_FLUSH) != Z_OK) { TIFFError(module, "%s: Encoder error: %s", tif->tif_name, sp->stream.msg); return (0); } if (sp->stream.avail_out == 0) { tif->tif_rawcc = tif->tif_rawdatasize; TIFFFlushData1(tif); sp->stream.next_out = tif->tif_rawdata; sp->stream.avail_out = tif->tif_rawdatasize; } } while (sp->stream.avail_in > 0); return (1); } /* * Finish off an encoded strip by flushing the last * string and tacking on an End Of Information code. */ static int PixarLogPostEncode(TIFF* tif) { PixarLogState *sp = EncoderState(tif); static const char module[] = "PixarLogPostEncode"; int state; sp->stream.avail_in = 0; do { state = deflate(&sp->stream, Z_FINISH); switch (state) { case Z_STREAM_END: case Z_OK: if (sp->stream.avail_out != tif->tif_rawdatasize) { tif->tif_rawcc = tif->tif_rawdatasize - sp->stream.avail_out; TIFFFlushData1(tif); sp->stream.next_out = tif->tif_rawdata; sp->stream.avail_out = tif->tif_rawdatasize; } break; default: TIFFError(module, "%s: zlib error: %s", tif->tif_name, sp->stream.msg); return (0); } } while (state != Z_STREAM_END); return (1); } static void PixarLogClose(TIFF* tif) { TIFFDirectory *td = &tif->tif_dir; /* In a really sneaky maneuver, on close, we covertly modify both * bitspersample and sampleformat in the directory to indicate * 8-bit linear. This way, the decode "just works" even for * readers that don't know about PixarLog, or how to set * the PIXARLOGDATFMT pseudo-tag. */ td->td_bitspersample = 8; td->td_sampleformat = SAMPLEFORMAT_UINT; } static void PixarLogCleanup(TIFF* tif) { PixarLogState* sp = (PixarLogState*) tif->tif_data; if (sp) { if (sp->FromLT2) _TIFFfree(sp->FromLT2); if (sp->From14) _TIFFfree(sp->From14); if (sp->From8) _TIFFfree(sp->From8); if (sp->ToLinearF) _TIFFfree(sp->ToLinearF); if (sp->ToLinear16) _TIFFfree(sp->ToLinear16); if (sp->ToLinear8) _TIFFfree(sp->ToLinear8); if (sp->state&PLSTATE_INIT) { if (tif->tif_mode == O_RDONLY) inflateEnd(&sp->stream); else deflateEnd(&sp->stream); } if (sp->tbuf) _TIFFfree(sp->tbuf); _TIFFfree(sp); tif->tif_data = NULL; } } static int PixarLogVSetField(TIFF* tif, ttag_t tag, va_list ap) { PixarLogState *sp = (PixarLogState *)tif->tif_data; int result; static const char module[] = "PixarLogVSetField"; switch (tag) { case TIFFTAG_PIXARLOGQUALITY: sp->quality = va_arg(ap, int); if (tif->tif_mode != O_RDONLY && (sp->state&PLSTATE_INIT)) { if (deflateParams(&sp->stream, sp->quality, Z_DEFAULT_STRATEGY) != Z_OK) { TIFFError(module, "%s: zlib error: %s", tif->tif_name, sp->stream.msg); return (0); } } return (1); case TIFFTAG_PIXARLOGDATAFMT: sp->user_datafmt = va_arg(ap, int); /* Tweak the TIFF header so that the rest of libtiff knows what * size of data will be passed between app and library, and * assume that the app knows what it is doing and is not * confused by these header manipulations... */ switch (sp->user_datafmt) { case PIXARLOGDATAFMT_8BIT: case PIXARLOGDATAFMT_8BITABGR: TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8); TIFFSetField(tif, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_UINT); break; case PIXARLOGDATAFMT_11BITLOG: TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 16); TIFFSetField(tif, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_UINT); break; case PIXARLOGDATAFMT_12BITPICIO: TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 16); TIFFSetField(tif, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_INT); break; case PIXARLOGDATAFMT_16BIT: TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 16); TIFFSetField(tif, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_UINT); break; case PIXARLOGDATAFMT_FLOAT: TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 32); TIFFSetField(tif, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_IEEEFP); break; } /* * Must recalculate sizes should bits/sample change. */ tif->tif_tilesize = TIFFTileSize(tif); tif->tif_scanlinesize = TIFFScanlineSize(tif); result = 1; /* NB: pseudo tag */ break; default: result = (*sp->vsetparent)(tif, tag, ap); } return (result); } static int PixarLogVGetField(TIFF* tif, ttag_t tag, va_list ap) { PixarLogState *sp = (PixarLogState *)tif->tif_data; switch (tag) { case TIFFTAG_PIXARLOGQUALITY: *va_arg(ap, int*) = sp->quality; break; case TIFFTAG_PIXARLOGDATAFMT: *va_arg(ap, int*) = sp->user_datafmt; break; default: return (*sp->vgetparent)(tif, tag, ap); } return (1); } static const TIFFFieldInfo pixarlogFieldInfo[] = { {TIFFTAG_PIXARLOGDATAFMT,0,0,TIFF_ANY, FIELD_PSEUDO,FALSE,FALSE,""}, {TIFFTAG_PIXARLOGQUALITY,0,0,TIFF_ANY, FIELD_PSEUDO,FALSE,FALSE,""} }; int TIFFInitPixarLog(TIFF* tif, int scheme) { PixarLogState* sp; assert(scheme == COMPRESSION_PIXARLOG); /* * Allocate state block so tag methods have storage to record values. */ tif->tif_data = (tidata_t) _TIFFmalloc(sizeof (PixarLogState)); if (tif->tif_data == NULL) goto bad; sp = (PixarLogState*) tif->tif_data; memset(sp, 0, sizeof (*sp)); sp->stream.data_type = Z_BINARY; sp->user_datafmt = PIXARLOGDATAFMT_UNKNOWN; /* * Install codec methods. */ tif->tif_setupdecode = PixarLogSetupDecode; tif->tif_predecode = PixarLogPreDecode; tif->tif_decoderow = PixarLogDecode; tif->tif_decodestrip = PixarLogDecode; tif->tif_decodetile = PixarLogDecode; tif->tif_setupencode = PixarLogSetupEncode; tif->tif_preencode = PixarLogPreEncode; tif->tif_postencode = PixarLogPostEncode; tif->tif_encoderow = PixarLogEncode; tif->tif_encodestrip = PixarLogEncode; tif->tif_encodetile = PixarLogEncode; tif->tif_close = PixarLogClose; tif->tif_cleanup = PixarLogCleanup; /* Override SetField so we can handle our private pseudo-tag */ _TIFFMergeFieldInfo(tif, pixarlogFieldInfo, N(pixarlogFieldInfo)); sp->vgetparent = tif->tif_vgetfield; tif->tif_vgetfield = PixarLogVGetField; /* hook for codec tags */ sp->vsetparent = tif->tif_vsetfield; tif->tif_vsetfield = PixarLogVSetField; /* hook for codec tags */ /* Default values for codec-specific fields */ sp->quality = Z_DEFAULT_COMPRESSION; /* default comp. level */ sp->state = 0; /* we don't wish to use the predictor, * the default is none, which predictor value 1 */ (void) TIFFPredictorInit(tif); /* * build the companding tables */ PixarLogMakeTables(sp); return (1); bad: TIFFError("TIFFInitPixarLog", "No space for PixarLog state block"); return (0); } #endif /* PIXARLOG_SUPPORT */ netpbm-8.2/libtiff/tif_predict.c0100660000076400000000000002724507020050200015740 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_predict.c,v 1.2 1999/11/27 21:43:28 warmerda Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library. * * Predictor Tag Support (used by multiple codecs). */ #include "tiffiop.h" #include "tif_predict.h" #include #define PredictorState(tif) ((TIFFPredictorState*) (tif)->tif_data) static void horAcc8(TIFF*, tidata_t, tsize_t); static void horAcc16(TIFF*, tidata_t, tsize_t); static void swabHorAcc16(TIFF*, tidata_t, tsize_t); static void horDiff8(TIFF*, tidata_t, tsize_t); static void horDiff16(TIFF*, tidata_t, tsize_t); static int PredictorDecodeRow(TIFF*, tidata_t, tsize_t, tsample_t); static int PredictorDecodeTile(TIFF*, tidata_t, tsize_t, tsample_t); static int PredictorEncodeRow(TIFF*, tidata_t, tsize_t, tsample_t); static int PredictorEncodeTile(TIFF*, tidata_t, tsize_t, tsample_t); static int PredictorSetup(TIFF* tif) { TIFFPredictorState* sp = PredictorState(tif); TIFFDirectory* td = &tif->tif_dir; if (sp->predictor == 1) /* no differencing */ return (1); if (sp->predictor != 2) { TIFFError(tif->tif_name, "\"Predictor\" value %d not supported", sp->predictor); return (0); } if (td->td_bitspersample != 8 && td->td_bitspersample != 16) { TIFFError(tif->tif_name, "Horizontal differencing \"Predictor\" not supported with %d-bit samples", td->td_bitspersample); return (0); } sp->stride = (td->td_planarconfig == PLANARCONFIG_CONTIG ? td->td_samplesperpixel : 1); /* * Calculate the scanline/tile-width size in bytes. */ if (isTiled(tif)) sp->rowsize = TIFFTileRowSize(tif); else sp->rowsize = TIFFScanlineSize(tif); return (1); } static int PredictorSetupDecode(TIFF* tif) { TIFFPredictorState* sp = PredictorState(tif); TIFFDirectory* td = &tif->tif_dir; if (!(*sp->setupdecode)(tif) || !PredictorSetup(tif)) return (0); if (sp->predictor == 2) { switch (td->td_bitspersample) { case 8: sp->pfunc = horAcc8; break; case 16: sp->pfunc = horAcc16; break; } /* * Override default decoding method with * one that does the predictor stuff. */ sp->coderow = tif->tif_decoderow; tif->tif_decoderow = PredictorDecodeRow; sp->codestrip = tif->tif_decodestrip; tif->tif_decodestrip = PredictorDecodeTile; sp->codetile = tif->tif_decodetile; tif->tif_decodetile = PredictorDecodeTile; /* * If the data is horizontally differenced * 16-bit data that requires byte-swapping, * then it must be byte swapped before the * accumulation step. We do this with a * special-purpose routine and override the * normal post decoding logic that the library * setup when the directory was read. */ if (tif->tif_flags&TIFF_SWAB) { if (sp->pfunc == horAcc16) { sp->pfunc = swabHorAcc16; tif->tif_postdecode = _TIFFNoPostDecode; } /* else handle 32-bit case... */ } } return (1); } static int PredictorSetupEncode(TIFF* tif) { TIFFPredictorState* sp = PredictorState(tif); TIFFDirectory* td = &tif->tif_dir; if (!(*sp->setupencode)(tif) || !PredictorSetup(tif)) return (0); if (sp->predictor == 2) { switch (td->td_bitspersample) { case 8: sp->pfunc = horDiff8; break; case 16: sp->pfunc = horDiff16; break; } /* * Override default encoding method with * one that does the predictor stuff. */ sp->coderow = tif->tif_encoderow; tif->tif_encoderow = PredictorEncodeRow; sp->codestrip = tif->tif_encodestrip; tif->tif_encodestrip = PredictorEncodeTile; sp->codetile = tif->tif_encodetile; tif->tif_encodetile = PredictorEncodeTile; } return (1); } #define REPEAT4(n, op) \ switch (n) { \ default: { int i; for (i = n-4; i > 0; i--) { op; } } \ case 4: op; \ case 3: op; \ case 2: op; \ case 1: op; \ case 0: ; \ } static void horAcc8(TIFF* tif, tidata_t cp0, tsize_t cc) { TIFFPredictorState* sp = PredictorState(tif); tsize_t stride = sp->stride; char* cp = (char*) cp0; if (cc > stride) { cc -= stride; /* * Pipeline the most common cases. */ if (stride == 3) { u_int cr = cp[0]; u_int cg = cp[1]; u_int cb = cp[2]; do { cc -= 3, cp += 3; cp[0] = (cr += cp[0]); cp[1] = (cg += cp[1]); cp[2] = (cb += cp[2]); } while ((int32) cc > 0); } else if (stride == 4) { u_int cr = cp[0]; u_int cg = cp[1]; u_int cb = cp[2]; u_int ca = cp[3]; do { cc -= 4, cp += 4; cp[0] = (cr += cp[0]); cp[1] = (cg += cp[1]); cp[2] = (cb += cp[2]); cp[3] = (ca += cp[3]); } while ((int32) cc > 0); } else { do { REPEAT4(stride, cp[stride] += *cp; cp++) cc -= stride; } while ((int32) cc > 0); } } } static void swabHorAcc16(TIFF* tif, tidata_t cp0, tsize_t cc) { TIFFPredictorState* sp = PredictorState(tif); tsize_t stride = sp->stride; uint16* wp = (uint16*) cp0; tsize_t wc = cc / 2; if (wc > stride) { TIFFSwabArrayOfShort(wp, wc); wc -= stride; do { REPEAT4(stride, wp[stride] += wp[0]; wp++) wc -= stride; } while ((int32) wc > 0); } } static void horAcc16(TIFF* tif, tidata_t cp0, tsize_t cc) { tsize_t stride = PredictorState(tif)->stride; uint16* wp = (uint16*) cp0; tsize_t wc = cc / 2; if (wc > stride) { wc -= stride; do { REPEAT4(stride, wp[stride] += wp[0]; wp++) wc -= stride; } while ((int32) wc > 0); } } /* * Decode a scanline and apply the predictor routine. */ static int PredictorDecodeRow(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) { TIFFPredictorState *sp = PredictorState(tif); assert(sp != NULL); assert(sp->coderow != NULL); assert(sp->pfunc != NULL); if ((*sp->coderow)(tif, op0, occ0, s)) { (*sp->pfunc)(tif, op0, occ0); return (1); } else return (0); } /* * Decode a tile/strip and apply the predictor routine. * Note that horizontal differencing must be done on a * row-by-row basis. The width of a "row" has already * been calculated at pre-decode time according to the * strip/tile dimensions. */ static int PredictorDecodeTile(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s) { TIFFPredictorState *sp = PredictorState(tif); assert(sp != NULL); assert(sp->codetile != NULL); if ((*sp->codetile)(tif, op0, occ0, s)) { tsize_t rowsize = sp->rowsize; assert(rowsize > 0); assert(sp->pfunc != NULL); while ((long)occ0 > 0) { (*sp->pfunc)(tif, op0, (tsize_t) rowsize); occ0 -= rowsize; op0 += rowsize; } return (1); } else return (0); } static void horDiff8(TIFF* tif, tidata_t cp0, tsize_t cc) { TIFFPredictorState* sp = PredictorState(tif); tsize_t stride = sp->stride; char* cp = (char*) cp0; if (cc > stride) { cc -= stride; /* * Pipeline the most common cases. */ if (stride == 3) { int r1, g1, b1; int r2 = cp[0]; int g2 = cp[1]; int b2 = cp[2]; do { r1 = cp[3]; cp[3] = r1-r2; r2 = r1; g1 = cp[4]; cp[4] = g1-g2; g2 = g1; b1 = cp[5]; cp[5] = b1-b2; b2 = b1; cp += 3; } while ((int32)(cc -= 3) > 0); } else if (stride == 4) { int r1, g1, b1, a1; int r2 = cp[0]; int g2 = cp[1]; int b2 = cp[2]; int a2 = cp[3]; do { r1 = cp[4]; cp[4] = r1-r2; r2 = r1; g1 = cp[5]; cp[5] = g1-g2; g2 = g1; b1 = cp[6]; cp[6] = b1-b2; b2 = b1; a1 = cp[7]; cp[7] = a1-a2; a2 = a1; cp += 4; } while ((int32)(cc -= 4) > 0); } else { cp += cc - 1; do { REPEAT4(stride, cp[stride] -= cp[0]; cp--) } while ((int32)(cc -= stride) > 0); } } } static void horDiff16(TIFF* tif, tidata_t cp0, tsize_t cc) { TIFFPredictorState* sp = PredictorState(tif); tsize_t stride = sp->stride; int16 *wp = (int16*) cp0; tsize_t wc = cc/2; if (wc > stride) { wc -= stride; wp += wc - 1; do { REPEAT4(stride, wp[stride] -= wp[0]; wp--) wc -= stride; } while ((int32) wc > 0); } } static int PredictorEncodeRow(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) { TIFFPredictorState *sp = PredictorState(tif); assert(sp != NULL); assert(sp->pfunc != NULL); assert(sp->coderow != NULL); /* XXX horizontal differencing alters user's data XXX */ (*sp->pfunc)(tif, bp, cc); return ((*sp->coderow)(tif, bp, cc, s)); } static int PredictorEncodeTile(TIFF* tif, tidata_t bp0, tsize_t cc0, tsample_t s) { TIFFPredictorState *sp = PredictorState(tif); tsize_t cc = cc0, rowsize; u_char* bp = bp0; assert(sp != NULL); assert(sp->pfunc != NULL); assert(sp->codetile != NULL); rowsize = sp->rowsize; assert(rowsize > 0); while ((long)cc > 0) { (*sp->pfunc)(tif, bp, (tsize_t) rowsize); cc -= rowsize; bp += rowsize; } return ((*sp->codetile)(tif, bp0, cc0, s)); } #define FIELD_PREDICTOR (FIELD_CODEC+0) /* XXX */ static const TIFFFieldInfo predictFieldInfo[] = { { TIFFTAG_PREDICTOR, 1, 1, TIFF_SHORT, FIELD_PREDICTOR, FALSE, FALSE, "Predictor" }, }; #define N(a) (sizeof (a) / sizeof (a[0])) static int PredictorVSetField(TIFF* tif, ttag_t tag, va_list ap) { TIFFPredictorState *sp = PredictorState(tif); switch (tag) { case TIFFTAG_PREDICTOR: sp->predictor = (uint16) va_arg(ap, int); TIFFSetFieldBit(tif, FIELD_PREDICTOR); break; default: return (*sp->vsetparent)(tif, tag, ap); } tif->tif_flags |= TIFF_DIRTYDIRECT; return (1); } static int PredictorVGetField(TIFF* tif, ttag_t tag, va_list ap) { TIFFPredictorState *sp = PredictorState(tif); switch (tag) { case TIFFTAG_PREDICTOR: *va_arg(ap, uint16*) = sp->predictor; break; default: return (*sp->vgetparent)(tif, tag, ap); } return (1); } static void PredictorPrintDir(TIFF* tif, FILE* fd, long flags) { TIFFPredictorState* sp = PredictorState(tif); (void) flags; if (TIFFFieldSet(tif,FIELD_PREDICTOR)) { fprintf(fd, " Predictor: "); switch (sp->predictor) { case 1: fprintf(fd, "none "); break; case 2: fprintf(fd, "horizontal differencing "); break; } fprintf(fd, "%u (0x%x)\n", sp->predictor, sp->predictor); } if (sp->printdir) (*sp->printdir)(tif, fd, flags); } int TIFFPredictorInit(TIFF* tif) { TIFFPredictorState* sp = PredictorState(tif); /* * Merge codec-specific tag information and * override parent get/set field methods. */ _TIFFMergeFieldInfo(tif, predictFieldInfo, N(predictFieldInfo)); sp->vgetparent = tif->tif_vgetfield; tif->tif_vgetfield = PredictorVGetField;/* hook for predictor tag */ sp->vsetparent = tif->tif_vsetfield; tif->tif_vsetfield = PredictorVSetField;/* hook for predictor tag */ sp->printdir = tif->tif_printdir; tif->tif_printdir = PredictorPrintDir; /* hook for predictor tag */ sp->setupdecode = tif->tif_setupdecode; tif->tif_setupdecode = PredictorSetupDecode; sp->setupencode = tif->tif_setupencode; tif->tif_setupencode = PredictorSetupEncode; sp->predictor = 1; /* default value */ sp->pfunc = NULL; /* no predictor routine */ return (1); } netpbm-8.2/libtiff/tif_predict.h0100660000076400000000000000462106747424643015775 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_predict.h,v 1.1.1.1 1999/07/27 21:50:27 mike Exp $ */ /* * Copyright (c) 1995-1997 Sam Leffler * Copyright (c) 1995-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * 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. */ #ifndef _TIFFPREDICT_ #define _TIFFPREDICT_ /* * ``Library-private'' Support for the Predictor Tag */ /* * Codecs that want to support the Predictor tag must place * this structure first in their private state block so that * the predictor code can cast tif_data to find its state. */ typedef struct { int predictor; /* predictor tag value */ int stride; /* sample stride over data */ tsize_t rowsize; /* tile/strip row size */ TIFFPostMethod pfunc; /* horizontal differencer/accumulator */ TIFFCodeMethod coderow; /* parent codec encode/decode row */ TIFFCodeMethod codestrip; /* parent codec encode/decode strip */ TIFFCodeMethod codetile; /* parent codec encode/decode tile */ TIFFVGetMethod vgetparent; /* super-class method */ TIFFVSetMethod vsetparent; /* super-class method */ TIFFPrintMethod printdir; /* super-class method */ TIFFBoolMethod setupdecode; /* super-class method */ TIFFBoolMethod setupencode; /* super-class method */ } TIFFPredictorState; #if defined(__cplusplus) extern "C" { #endif extern int TIFFPredictorInit(TIFF*); #if defined(__cplusplus) } #endif #endif /* _TIFFPREDICT_ */ netpbm-8.2/libtiff/tif_print.c0100660000076400000000000004023507027731307015461 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_print.c,v 1.2 1999/12/21 17:03:03 mwelles Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library. * * Directory Printing Support */ #include "tiffiop.h" #include #include static const char *photoNames[] = { "min-is-white", /* PHOTOMETRIC_MINISWHITE */ "min-is-black", /* PHOTOMETRIC_MINISBLACK */ "RGB color", /* PHOTOMETRIC_RGB */ "palette color (RGB from colormap)", /* PHOTOMETRIC_PALETTE */ "transparency mask", /* PHOTOMETRIC_MASK */ "separated", /* PHOTOMETRIC_SEPARATED */ "YCbCr", /* PHOTOMETRIC_YCBCR */ "7 (0x7)", "CIE L*a*b*", /* PHOTOMETRIC_CIELAB */ }; #define NPHOTONAMES (sizeof (photoNames) / sizeof (photoNames[0])) static const char *orientNames[] = { "0 (0x0)", "row 0 top, col 0 lhs", /* ORIENTATION_TOPLEFT */ "row 0 top, col 0 rhs", /* ORIENTATION_TOPRIGHT */ "row 0 bottom, col 0 rhs", /* ORIENTATION_BOTRIGHT */ "row 0 bottom, col 0 lhs", /* ORIENTATION_BOTLEFT */ "row 0 lhs, col 0 top", /* ORIENTATION_LEFTTOP */ "row 0 rhs, col 0 top", /* ORIENTATION_RIGHTTOP */ "row 0 rhs, col 0 bottom", /* ORIENTATION_RIGHTBOT */ "row 0 lhs, col 0 bottom", /* ORIENTATION_LEFTBOT */ }; #define NORIENTNAMES (sizeof (orientNames) / sizeof (orientNames[0])) /* * Print the contents of the current directory * to the specified stdio file stream. */ void TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags) { register TIFFDirectory *td; char *sep; uint16 i; long l, n; fprintf(fd, "TIFF Directory at offset 0x%lx\n", (long) tif->tif_diroff); td = &tif->tif_dir; if (TIFFFieldSet(tif,FIELD_SUBFILETYPE)) { fprintf(fd, " Subfile Type:"); sep = " "; if (td->td_subfiletype & FILETYPE_REDUCEDIMAGE) { fprintf(fd, "%sreduced-resolution image", sep); sep = "/"; } if (td->td_subfiletype & FILETYPE_PAGE) { fprintf(fd, "%smulti-page document", sep); sep = "/"; } if (td->td_subfiletype & FILETYPE_MASK) fprintf(fd, "%stransparency mask", sep); fprintf(fd, " (%lu = 0x%lx)\n", (long) td->td_subfiletype, (long) td->td_subfiletype); } if (TIFFFieldSet(tif,FIELD_IMAGEDIMENSIONS)) { fprintf(fd, " Image Width: %lu Image Length: %lu", (u_long) td->td_imagewidth, (u_long) td->td_imagelength); if (TIFFFieldSet(tif,FIELD_IMAGEDEPTH)) fprintf(fd, " Image Depth: %lu", (u_long) td->td_imagedepth); fprintf(fd, "\n"); } /* Begin Pixar */ if (TIFFFieldSet(tif,FIELD_IMAGEFULLWIDTH) || TIFFFieldSet(tif,FIELD_IMAGEFULLLENGTH)) { fprintf(fd, " Pixar Full Image Width: %lu Full Image Length: %lu\n", (u_long) td->td_imagefullwidth, (u_long) td->td_imagefulllength); } if (TIFFFieldSet(tif,FIELD_TEXTUREFORMAT)) _TIFFprintAsciiTag(fd, "Texture Format", td->td_textureformat); if (TIFFFieldSet(tif,FIELD_WRAPMODES)) _TIFFprintAsciiTag(fd, "Texture Wrap Modes", td->td_wrapmodes); if (TIFFFieldSet(tif,FIELD_FOVCOT)) fprintf(fd, " Field of View Cotangent: %g\n", td->td_fovcot); if (TIFFFieldSet(tif,FIELD_MATRIX_WORLDTOSCREEN)) { typedef float Matrix[4][4]; Matrix* m = (Matrix*)td->td_matrixWorldToScreen; fprintf(fd, " Matrix NP:\n\t%g %g %g %g\n\t%g %g %g %g\n\t%g %g %g %g\n\t%g %g %g %g\n", (*m)[0][0], (*m)[0][1], (*m)[0][2], (*m)[0][3], (*m)[1][0], (*m)[1][1], (*m)[1][2], (*m)[1][3], (*m)[2][0], (*m)[2][1], (*m)[2][2], (*m)[2][3], (*m)[3][0], (*m)[3][1], (*m)[3][2], (*m)[3][3]); } if (TIFFFieldSet(tif,FIELD_MATRIX_WORLDTOCAMERA)) { typedef float Matrix[4][4]; Matrix* m = (Matrix*)td->td_matrixWorldToCamera; fprintf(fd, " Matrix Nl:\n\t%g %g %g %g\n\t%g %g %g %g\n\t%g %g %g %g\n\t%g %g %g %g\n", (*m)[0][0], (*m)[0][1], (*m)[0][2], (*m)[0][3], (*m)[1][0], (*m)[1][1], (*m)[1][2], (*m)[1][3], (*m)[2][0], (*m)[2][1], (*m)[2][2], (*m)[2][3], (*m)[3][0], (*m)[3][1], (*m)[3][2], (*m)[3][3]); } /* End Pixar */ if (TIFFFieldSet(tif,FIELD_TILEDIMENSIONS)) { fprintf(fd, " Tile Width: %lu Tile Length: %lu", (u_long) td->td_tilewidth, (u_long) td->td_tilelength); if (TIFFFieldSet(tif,FIELD_TILEDEPTH)) fprintf(fd, " Tile Depth: %lu", (u_long) td->td_tiledepth); fprintf(fd, "\n"); } if (TIFFFieldSet(tif,FIELD_RESOLUTION)) { fprintf(fd, " Resolution: %g, %g", td->td_xresolution, td->td_yresolution); if (TIFFFieldSet(tif,FIELD_RESOLUTIONUNIT)) { switch (td->td_resolutionunit) { case RESUNIT_NONE: fprintf(fd, " (unitless)"); break; case RESUNIT_INCH: fprintf(fd, " pixels/inch"); break; case RESUNIT_CENTIMETER: fprintf(fd, " pixels/cm"); break; default: fprintf(fd, " (unit %u = 0x%x)", td->td_resolutionunit, td->td_resolutionunit); break; } } fprintf(fd, "\n"); } if (TIFFFieldSet(tif,FIELD_POSITION)) fprintf(fd, " Position: %g, %g\n", td->td_xposition, td->td_yposition); if (TIFFFieldSet(tif,FIELD_BITSPERSAMPLE)) fprintf(fd, " Bits/Sample: %u\n", td->td_bitspersample); if (TIFFFieldSet(tif,FIELD_SAMPLEFORMAT)) { fprintf(fd, " Sample Format: "); switch (td->td_sampleformat) { case SAMPLEFORMAT_VOID: fprintf(fd, "void\n"); break; case SAMPLEFORMAT_INT: fprintf(fd, "signed integer\n"); break; case SAMPLEFORMAT_UINT: fprintf(fd, "unsigned integer\n"); break; case SAMPLEFORMAT_IEEEFP: fprintf(fd, "IEEE floating point\n"); break; default: fprintf(fd, "%u (0x%x)\n", td->td_sampleformat, td->td_sampleformat); break; } } if (TIFFFieldSet(tif,FIELD_COMPRESSION)) { const TIFFCodec* c = TIFFFindCODEC(td->td_compression); fprintf(fd, " Compression Scheme: "); if (c) fprintf(fd, "%s\n", c->name); else fprintf(fd, "%u (0x%x)\n", td->td_compression, td->td_compression); } if (TIFFFieldSet(tif,FIELD_PHOTOMETRIC)) { fprintf(fd, " Photometric Interpretation: "); if (td->td_photometric < NPHOTONAMES) fprintf(fd, "%s\n", photoNames[td->td_photometric]); else { switch (td->td_photometric) { case PHOTOMETRIC_LOGL: fprintf(fd, "CIE Log2(L)\n"); break; case PHOTOMETRIC_LOGLUV: fprintf(fd, "CIE Log2(L) (u',v')\n"); break; default: fprintf(fd, "%u (0x%x)\n", td->td_photometric, td->td_photometric); break; } } } if (TIFFFieldSet(tif,FIELD_EXTRASAMPLES) && td->td_extrasamples) { fprintf(fd, " Extra Samples: %u<", td->td_extrasamples); sep = ""; for (i = 0; i < td->td_extrasamples; i++) { switch (td->td_sampleinfo[i]) { case EXTRASAMPLE_UNSPECIFIED: fprintf(fd, "%sunspecified", sep); break; case EXTRASAMPLE_ASSOCALPHA: fprintf(fd, "%sassoc-alpha", sep); break; case EXTRASAMPLE_UNASSALPHA: fprintf(fd, "%sunassoc-alpha", sep); break; default: fprintf(fd, "%s%u (0x%x)", sep, td->td_sampleinfo[i], td->td_sampleinfo[i]); break; } sep = ", "; } fprintf(fd, ">\n"); } if (TIFFFieldSet(tif,FIELD_STONITS)) { fprintf(fd, " Sample to Nits conversion factor: %.4e\n", td->td_stonits); } #ifdef CMYK_SUPPORT if (TIFFFieldSet(tif,FIELD_INKSET)) { fprintf(fd, " Ink Set: "); switch (td->td_inkset) { case INKSET_CMYK: fprintf(fd, "CMYK\n"); break; default: fprintf(fd, "%u (0x%x)\n", td->td_inkset, td->td_inkset); break; } } if (TIFFFieldSet(tif,FIELD_INKNAMES)) { char* cp; fprintf(fd, " Ink Names: "); i = td->td_samplesperpixel; sep = ""; for (cp = td->td_inknames; i > 0; cp = strchr(cp,'\0')+1, i--) { fprintf(fd, "%s", sep); _TIFFprintAscii(fd, cp); sep = ", "; } } if (TIFFFieldSet(tif,FIELD_NUMBEROFINKS)) fprintf(fd, " Number of Inks: %u\n", td->td_ninks); if (TIFFFieldSet(tif,FIELD_DOTRANGE)) fprintf(fd, " Dot Range: %u-%u\n", td->td_dotrange[0], td->td_dotrange[1]); if (TIFFFieldSet(tif,FIELD_TARGETPRINTER)) _TIFFprintAsciiTag(fd, "Target Printer", td->td_targetprinter); #endif if (TIFFFieldSet(tif,FIELD_THRESHHOLDING)) { fprintf(fd, " Thresholding: "); switch (td->td_threshholding) { case THRESHHOLD_BILEVEL: fprintf(fd, "bilevel art scan\n"); break; case THRESHHOLD_HALFTONE: fprintf(fd, "halftone or dithered scan\n"); break; case THRESHHOLD_ERRORDIFFUSE: fprintf(fd, "error diffused\n"); break; default: fprintf(fd, "%u (0x%x)\n", td->td_threshholding, td->td_threshholding); break; } } if (TIFFFieldSet(tif,FIELD_FILLORDER)) { fprintf(fd, " FillOrder: "); switch (td->td_fillorder) { case FILLORDER_MSB2LSB: fprintf(fd, "msb-to-lsb\n"); break; case FILLORDER_LSB2MSB: fprintf(fd, "lsb-to-msb\n"); break; default: fprintf(fd, "%u (0x%x)\n", td->td_fillorder, td->td_fillorder); break; } } #ifdef YCBCR_SUPPORT if (TIFFFieldSet(tif,FIELD_YCBCRSUBSAMPLING)) fprintf(fd, " YCbCr Subsampling: %u, %u\n", td->td_ycbcrsubsampling[0], td->td_ycbcrsubsampling[1]); if (TIFFFieldSet(tif,FIELD_YCBCRPOSITIONING)) { fprintf(fd, " YCbCr Positioning: "); switch (td->td_ycbcrpositioning) { case YCBCRPOSITION_CENTERED: fprintf(fd, "centered\n"); break; case YCBCRPOSITION_COSITED: fprintf(fd, "cosited\n"); break; default: fprintf(fd, "%u (0x%x)\n", td->td_ycbcrpositioning, td->td_ycbcrpositioning); break; } } if (TIFFFieldSet(tif,FIELD_YCBCRCOEFFICIENTS)) fprintf(fd, " YCbCr Coefficients: %g, %g, %g\n", td->td_ycbcrcoeffs[0], td->td_ycbcrcoeffs[1], td->td_ycbcrcoeffs[2]); #endif if (TIFFFieldSet(tif,FIELD_HALFTONEHINTS)) fprintf(fd, " Halftone Hints: light %u dark %u\n", td->td_halftonehints[0], td->td_halftonehints[1]); if (TIFFFieldSet(tif,FIELD_ARTIST)) _TIFFprintAsciiTag(fd, "Artist", td->td_artist); if (TIFFFieldSet(tif,FIELD_DATETIME)) _TIFFprintAsciiTag(fd, "Date & Time", td->td_datetime); if (TIFFFieldSet(tif,FIELD_HOSTCOMPUTER)) _TIFFprintAsciiTag(fd, "Host Computer", td->td_hostcomputer); if (TIFFFieldSet(tif,FIELD_SOFTWARE)) _TIFFprintAsciiTag(fd, "Software", td->td_software); if (TIFFFieldSet(tif,FIELD_DOCUMENTNAME)) _TIFFprintAsciiTag(fd, "Document Name", td->td_documentname); if (TIFFFieldSet(tif,FIELD_IMAGEDESCRIPTION)) _TIFFprintAsciiTag(fd, "Image Description", td->td_imagedescription); if (TIFFFieldSet(tif,FIELD_MAKE)) _TIFFprintAsciiTag(fd, "Make", td->td_make); if (TIFFFieldSet(tif,FIELD_MODEL)) _TIFFprintAsciiTag(fd, "Model", td->td_model); if (TIFFFieldSet(tif,FIELD_ORIENTATION)) { fprintf(fd, " Orientation: "); if (td->td_orientation < NORIENTNAMES) fprintf(fd, "%s\n", orientNames[td->td_orientation]); else fprintf(fd, "%u (0x%x)\n", td->td_orientation, td->td_orientation); } if (TIFFFieldSet(tif,FIELD_SAMPLESPERPIXEL)) fprintf(fd, " Samples/Pixel: %u\n", td->td_samplesperpixel); if (TIFFFieldSet(tif,FIELD_ROWSPERSTRIP)) { fprintf(fd, " Rows/Strip: "); if (td->td_rowsperstrip == (uint32) -1) fprintf(fd, "(infinite)\n"); else fprintf(fd, "%lu\n", (u_long) td->td_rowsperstrip); } if (TIFFFieldSet(tif,FIELD_MINSAMPLEVALUE)) fprintf(fd, " Min Sample Value: %u\n", td->td_minsamplevalue); if (TIFFFieldSet(tif,FIELD_MAXSAMPLEVALUE)) fprintf(fd, " Max Sample Value: %u\n", td->td_maxsamplevalue); if (TIFFFieldSet(tif,FIELD_SMINSAMPLEVALUE)) fprintf(fd, " SMin Sample Value: %g\n", td->td_sminsamplevalue); if (TIFFFieldSet(tif,FIELD_SMAXSAMPLEVALUE)) fprintf(fd, " SMax Sample Value: %g\n", td->td_smaxsamplevalue); if (TIFFFieldSet(tif,FIELD_PLANARCONFIG)) { fprintf(fd, " Planar Configuration: "); switch (td->td_planarconfig) { case PLANARCONFIG_CONTIG: fprintf(fd, "single image plane\n"); break; case PLANARCONFIG_SEPARATE: fprintf(fd, "separate image planes\n"); break; default: fprintf(fd, "%u (0x%x)\n", td->td_planarconfig, td->td_planarconfig); break; } } if (TIFFFieldSet(tif,FIELD_PAGENAME)) _TIFFprintAsciiTag(fd, "Page Name", td->td_pagename); if (TIFFFieldSet(tif,FIELD_PAGENUMBER)) fprintf(fd, " Page Number: %u-%u\n", td->td_pagenumber[0], td->td_pagenumber[1]); if (TIFFFieldSet(tif,FIELD_COLORMAP)) { fprintf(fd, " Color Map: "); if (flags & TIFFPRINT_COLORMAP) { fprintf(fd, "\n"); n = 1L<td_bitspersample; for (l = 0; l < n; l++) fprintf(fd, " %5lu: %5u %5u %5u\n", l, td->td_colormap[0][l], td->td_colormap[1][l], td->td_colormap[2][l]); } else fprintf(fd, "(present)\n"); } #ifdef COLORIMETRY_SUPPORT if (TIFFFieldSet(tif,FIELD_WHITEPOINT)) fprintf(fd, " White Point: %g-%g\n", td->td_whitepoint[0], td->td_whitepoint[1]); if (TIFFFieldSet(tif,FIELD_PRIMARYCHROMAS)) fprintf(fd, " Primary Chromaticities: %g,%g %g,%g %g,%g\n", td->td_primarychromas[0], td->td_primarychromas[1], td->td_primarychromas[2], td->td_primarychromas[3], td->td_primarychromas[4], td->td_primarychromas[5]); if (TIFFFieldSet(tif,FIELD_REFBLACKWHITE)) { fprintf(fd, " Reference Black/White:\n"); for (i = 0; i < td->td_samplesperpixel; i++) fprintf(fd, " %2d: %5g %5g\n", i, td->td_refblackwhite[2*i+0], td->td_refblackwhite[2*i+1]); } if (TIFFFieldSet(tif,FIELD_TRANSFERFUNCTION)) { fprintf(fd, " Transfer Function: "); if (flags & TIFFPRINT_CURVES) { fprintf(fd, "\n"); n = 1L<td_bitspersample; for (l = 0; l < n; l++) { fprintf(fd, " %2lu: %5u", l, td->td_transferfunction[0][l]); for (i = 1; i < td->td_samplesperpixel; i++) fprintf(fd, " %5u", td->td_transferfunction[i][l]); fputc('\n', fd); } } else fprintf(fd, "(present)\n"); } #endif #ifdef ICC_SUPPORT if (TIFFFieldSet(tif,FIELD_ICCPROFILE)) fprintf(fd, " ICC Profile: , %lu bytes\n", (u_long) td->td_profileLength); #endif #ifdef PHOTOSHOP_SUPPORT if (TIFFFieldSet(tif,FIELD_PHOTOSHOP)) fprintf(fd, " Photoshop Data: , %lu bytes\n", (u_long) td->td_photoshopLength); #endif #ifdef IPTC_SUPPORT if (TIFFFieldSet(tif,FIELD_RICHTIFFIPTC)) fprintf(fd, " RichTIFFIPTC Data: , %lu bytes\n", (u_long) td->td_richtiffiptcLength); #endif #if SUBIFD_SUPPORT if (TIFFFieldSet(tif, FIELD_SUBIFD)) { fprintf(fd, " SubIFD Offsets:"); for (i = 0; i < td->td_nsubifd; i++) fprintf(fd, " %5lu", (long) td->td_subifd[i]); fputc('\n', fd); } #endif if (tif->tif_printdir) (*tif->tif_printdir)(tif, fd, flags); if ((flags & TIFFPRINT_STRIPS) && TIFFFieldSet(tif,FIELD_STRIPOFFSETS)) { tstrip_t s; fprintf(fd, " %lu %s:\n", (long) td->td_nstrips, isTiled(tif) ? "Tiles" : "Strips"); for (s = 0; s < td->td_nstrips; s++) fprintf(fd, " %3lu: [%8lu, %8lu]\n", (u_long) s, (u_long) td->td_stripoffset[s], (u_long) td->td_stripbytecount[s]); } } void _TIFFprintAscii(FILE* fd, const char* cp) { for (; *cp != '\0'; cp++) { const char* tp; if (isprint(*cp)) { fputc(*cp, fd); continue; } for (tp = "\tt\bb\rr\nn\vv"; *tp; tp++) if (*tp++ == *cp) break; if (*tp) fprintf(fd, "\\%c", *tp); else fprintf(fd, "\\%03o", *cp & 0xff); } } void _TIFFprintAsciiTag(FILE* fd, const char* name, const char* value) { fprintf(fd, " %s: \"", name); _TIFFprintAscii(fd, value); fprintf(fd, "\"\n"); } netpbm-8.2/libtiff/tif_read.c0100660000076400000000000004311707020050651015227 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_read.c,v 1.3 1999/11/27 21:48:25 warmerda Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library. * Scanline-oriented Read Support */ #include "tiffiop.h" #include #include static int TIFFFillStrip(TIFF*, tstrip_t); static int TIFFFillTile(TIFF*, ttile_t); static int TIFFStartStrip(TIFF*, tstrip_t); static int TIFFStartTile(TIFF*, ttile_t); static int TIFFCheckRead(TIFF*, int); #define NOSTRIP ((tstrip_t) -1) /* undefined state */ #define NOTILE ((ttile_t) -1) /* undefined state */ /* * Seek to a random row+sample in a file. */ static int TIFFSeek(TIFF* tif, uint32 row, tsample_t sample) { register TIFFDirectory *td = &tif->tif_dir; tstrip_t strip; if (row >= td->td_imagelength) { /* out of range */ TIFFError(tif->tif_name, "%lu: Row out of range, max %lu", (u_long) row, (u_long) td->td_imagelength); return (0); } if (td->td_planarconfig == PLANARCONFIG_SEPARATE) { if (sample >= td->td_samplesperpixel) { TIFFError(tif->tif_name, "%lu: Sample out of range, max %lu", (u_long) sample, (u_long) td->td_samplesperpixel); return (0); } strip = sample*td->td_stripsperimage + row/td->td_rowsperstrip; } else strip = row / td->td_rowsperstrip; if (strip != tif->tif_curstrip) { /* different strip, refill */ if (!TIFFFillStrip(tif, strip)) return (0); } else if (row < tif->tif_row) { /* * Moving backwards within the same strip: backup * to the start and then decode forward (below). * * NB: If you're planning on lots of random access within a * strip, it's better to just read and decode the entire * strip, and then access the decoded data in a random fashion. */ if (!TIFFStartStrip(tif, strip)) return (0); } if (row != tif->tif_row) { /* * Seek forward to the desired row. */ if (!(*tif->tif_seek)(tif, row - tif->tif_row)) return (0); tif->tif_row = row; } return (1); } int TIFFReadScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample) { int e; if (!TIFFCheckRead(tif, 0)) return (-1); if( (e = TIFFSeek(tif, row, sample)) != 0) { /* * Decompress desired row into user buffer. */ e = (*tif->tif_decoderow) (tif, (tidata_t) buf, tif->tif_scanlinesize, sample); tif->tif_row++; if (e) (*tif->tif_postdecode)(tif, (tidata_t) buf, tif->tif_scanlinesize); } return (e > 0 ? 1 : -1); } /* * Read a strip of data and decompress the specified * amount into the user-supplied buffer. */ tsize_t TIFFReadEncodedStrip(TIFF* tif, tstrip_t strip, tdata_t buf, tsize_t size) { TIFFDirectory *td = &tif->tif_dir; uint32 nrows; tsize_t stripsize; if (!TIFFCheckRead(tif, 0)) return (-1); if (strip >= td->td_nstrips) { TIFFError(tif->tif_name, "%ld: Strip out of range, max %ld", (long) strip, (long) td->td_nstrips); return (-1); } /* * Calculate the strip size according to the number of * rows in the strip (check for truncated last strip). */ if (strip != td->td_nstrips-1 || (nrows = td->td_imagelength % td->td_rowsperstrip) == 0) nrows = td->td_rowsperstrip; stripsize = TIFFVStripSize(tif, nrows); if (size == (tsize_t) -1) size = stripsize; else if (size > stripsize) size = stripsize; if (TIFFFillStrip(tif, strip) && (*tif->tif_decodestrip)(tif, (tidata_t) buf, size, (tsample_t)(strip / td->td_stripsperimage))) { (*tif->tif_postdecode)(tif, (tidata_t) buf, size); return (size); } else return ((tsize_t) -1); } static tsize_t TIFFReadRawStrip1(TIFF* tif, tstrip_t strip, tdata_t buf, tsize_t size, const char* module) { TIFFDirectory *td = &tif->tif_dir; if (!isMapped(tif)) { tsize_t cc; if (!SeekOK(tif, td->td_stripoffset[strip])) { TIFFError(module, "%s: Seek error at scanline %lu, strip %lu", tif->tif_name, (u_long) tif->tif_row, (u_long) strip); return (-1); } cc = TIFFReadFile(tif, buf, size); if (cc != size) { TIFFError(module, "%s: Read error at scanline %lu; got %lu bytes, expected %lu", tif->tif_name, (u_long) tif->tif_row, (u_long) cc, (u_long) size); return (-1); } } else { if (((tsize_t) (td->td_stripoffset[strip] + size)) > tif->tif_size) { TIFFError(module, "%s: Read error at scanline %lu, strip %lu; got %lu bytes, expected %lu", tif->tif_name, (u_long) tif->tif_row, (u_long) strip, (u_long) tif->tif_size - td->td_stripoffset[strip], (u_long) size); return (-1); } _TIFFmemcpy(buf, tif->tif_base + td->td_stripoffset[strip], size); } return (size); } /* * Read a strip of data from the file. */ tsize_t TIFFReadRawStrip(TIFF* tif, tstrip_t strip, tdata_t buf, tsize_t size) { static const char module[] = "TIFFReadRawStrip"; TIFFDirectory *td = &tif->tif_dir; tsize_t bytecount; if (!TIFFCheckRead(tif, 0)) return ((tsize_t) -1); if (strip >= td->td_nstrips) { TIFFError(tif->tif_name, "%lu: Strip out of range, max %lu", (u_long) strip, (u_long) td->td_nstrips); return ((tsize_t) -1); } bytecount = td->td_stripbytecount[strip]; if (bytecount <= 0) { TIFFError(tif->tif_name, "%lu: Invalid strip byte count, strip %lu", (u_long) bytecount, (u_long) strip); return ((tsize_t) -1); } if (size != (tsize_t)-1 && size < bytecount) bytecount = size; return (TIFFReadRawStrip1(tif, strip, buf, bytecount, module)); } /* * Read the specified strip and setup for decoding. * The data buffer is expanded, as necessary, to * hold the strip's data. */ static int TIFFFillStrip(TIFF* tif, tstrip_t strip) { static const char module[] = "TIFFFillStrip"; TIFFDirectory *td = &tif->tif_dir; tsize_t bytecount; bytecount = td->td_stripbytecount[strip]; if (bytecount <= 0) { TIFFError(tif->tif_name, "%lu: Invalid strip byte count, strip %lu", (u_long) bytecount, (u_long) strip); return (0); } if (isMapped(tif) && (isFillOrder(tif, td->td_fillorder) || (tif->tif_flags & TIFF_NOBITREV))) { /* * The image is mapped into memory and we either don't * need to flip bits or the compression routine is going * to handle this operation itself. In this case, avoid * copying the raw data and instead just reference the * data from the memory mapped file image. This assumes * that the decompression routines do not modify the * contents of the raw data buffer (if they try to, * the application will get a fault since the file is * mapped read-only). */ if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) _TIFFfree(tif->tif_rawdata); tif->tif_flags &= ~TIFF_MYBUFFER; if (((tsize_t) td->td_stripoffset[strip] + bytecount) > tif->tif_size) { /* * This error message might seem strange, but it's * what would happen if a read were done instead. */ TIFFError(module, "%s: Read error on strip %lu; got %lu bytes, expected %lu", tif->tif_name, (u_long) strip, (u_long) tif->tif_size - td->td_stripoffset[strip], (u_long) bytecount); tif->tif_curstrip = NOSTRIP; return (0); } tif->tif_rawdatasize = bytecount; tif->tif_rawdata = tif->tif_base + td->td_stripoffset[strip]; } else { /* * Expand raw data buffer, if needed, to * hold data strip coming from file * (perhaps should set upper bound on * the size of a buffer we'll use?). */ if (bytecount > tif->tif_rawdatasize) { tif->tif_curstrip = NOSTRIP; if ((tif->tif_flags & TIFF_MYBUFFER) == 0) { TIFFError(module, "%s: Data buffer too small to hold strip %lu", tif->tif_name, (u_long) strip); return (0); } if (!TIFFReadBufferSetup(tif, 0, TIFFroundup(bytecount, 1024))) return (0); } if (TIFFReadRawStrip1(tif, strip, (u_char *)tif->tif_rawdata, bytecount, module) != bytecount) return (0); if (!isFillOrder(tif, td->td_fillorder) && (tif->tif_flags & TIFF_NOBITREV) == 0) TIFFReverseBits(tif->tif_rawdata, bytecount); } return (TIFFStartStrip(tif, strip)); } /* * Tile-oriented Read Support * Contributed by Nancy Cam (Silicon Graphics). */ /* * Read and decompress a tile of data. The * tile is selected by the (x,y,z,s) coordinates. */ tsize_t TIFFReadTile(TIFF* tif, tdata_t buf, uint32 x, uint32 y, uint32 z, tsample_t s) { if (!TIFFCheckRead(tif, 1) || !TIFFCheckTile(tif, x, y, z, s)) return (-1); return (TIFFReadEncodedTile(tif, TIFFComputeTile(tif, x, y, z, s), buf, (tsize_t) -1)); } /* * Read a tile of data and decompress the specified * amount into the user-supplied buffer. */ tsize_t TIFFReadEncodedTile(TIFF* tif, ttile_t tile, tdata_t buf, tsize_t size) { TIFFDirectory *td = &tif->tif_dir; tsize_t tilesize = tif->tif_tilesize; if (!TIFFCheckRead(tif, 1)) return (-1); if (tile >= td->td_nstrips) { TIFFError(tif->tif_name, "%ld: Tile out of range, max %ld", (long) tile, (u_long) td->td_nstrips); return (-1); } if (size == (tsize_t) -1) size = tilesize; else if (size > tilesize) size = tilesize; if (TIFFFillTile(tif, tile) && (*tif->tif_decodetile)(tif, (tidata_t) buf, size, (tsample_t)(tile/td->td_stripsperimage))) { (*tif->tif_postdecode)(tif, (tidata_t) buf, size); return (size); } else return (-1); } static tsize_t TIFFReadRawTile1(TIFF* tif, ttile_t tile, tdata_t buf, tsize_t size, const char* module) { TIFFDirectory *td = &tif->tif_dir; if (!isMapped(tif)) { tsize_t cc; if (!SeekOK(tif, td->td_stripoffset[tile])) { TIFFError(module, "%s: Seek error at row %ld, col %ld, tile %ld", tif->tif_name, (long) tif->tif_row, (long) tif->tif_col, (long) tile); return ((tsize_t) -1); } cc = TIFFReadFile(tif, buf, size); if (cc != size) { TIFFError(module, "%s: Read error at row %ld, col %ld; got %lu bytes, expected %lu", tif->tif_name, (long) tif->tif_row, (long) tif->tif_col, (u_long) cc, (u_long) size); return ((tsize_t) -1); } } else { if (((tsize_t) (td->td_stripoffset[tile] + size)) > tif->tif_size) { TIFFError(module, "%s: Read error at row %ld, col %ld, tile %ld; got %lu bytes, expected %lu", tif->tif_name, (long) tif->tif_row, (long) tif->tif_col, (long) tile, (u_long) tif->tif_size - td->td_stripoffset[tile], (u_long) size); return ((tsize_t) -1); } _TIFFmemcpy(buf, tif->tif_base + td->td_stripoffset[tile], size); } return (size); } /* * Read a tile of data from the file. */ tsize_t TIFFReadRawTile(TIFF* tif, ttile_t tile, tdata_t buf, tsize_t size) { static const char module[] = "TIFFReadRawTile"; TIFFDirectory *td = &tif->tif_dir; tsize_t bytecount; if (!TIFFCheckRead(tif, 1)) return ((tsize_t) -1); if (tile >= td->td_nstrips) { TIFFError(tif->tif_name, "%lu: Tile out of range, max %lu", (u_long) tile, (u_long) td->td_nstrips); return ((tsize_t) -1); } bytecount = td->td_stripbytecount[tile]; if (size != (tsize_t) -1 && size < bytecount) bytecount = size; return (TIFFReadRawTile1(tif, tile, buf, bytecount, module)); } /* * Read the specified tile and setup for decoding. * The data buffer is expanded, as necessary, to * hold the tile's data. */ static int TIFFFillTile(TIFF* tif, ttile_t tile) { static const char module[] = "TIFFFillTile"; TIFFDirectory *td = &tif->tif_dir; tsize_t bytecount; bytecount = td->td_stripbytecount[tile]; if (bytecount <= 0) { TIFFError(tif->tif_name, "%lu: Invalid tile byte count, tile %lu", (u_long) bytecount, (u_long) tile); return (0); } if (isMapped(tif) && (isFillOrder(tif, td->td_fillorder) || (tif->tif_flags & TIFF_NOBITREV))) { /* * The image is mapped into memory and we either don't * need to flip bits or the compression routine is going * to handle this operation itself. In this case, avoid * copying the raw data and instead just reference the * data from the memory mapped file image. This assumes * that the decompression routines do not modify the * contents of the raw data buffer (if they try to, * the application will get a fault since the file is * mapped read-only). */ if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) _TIFFfree(tif->tif_rawdata); tif->tif_flags &= ~TIFF_MYBUFFER; if ( ((tsize_t) (td->td_stripoffset[tile] + bytecount)) > tif->tif_size) { tif->tif_curtile = NOTILE; return (0); } tif->tif_rawdatasize = bytecount; tif->tif_rawdata = tif->tif_base + td->td_stripoffset[tile]; } else { /* * Expand raw data buffer, if needed, to * hold data tile coming from file * (perhaps should set upper bound on * the size of a buffer we'll use?). */ if (bytecount > tif->tif_rawdatasize) { tif->tif_curtile = NOTILE; if ((tif->tif_flags & TIFF_MYBUFFER) == 0) { TIFFError(module, "%s: Data buffer too small to hold tile %ld", tif->tif_name, (long) tile); return (0); } if (!TIFFReadBufferSetup(tif, 0, TIFFroundup(bytecount, 1024))) return (0); } if (TIFFReadRawTile1(tif, tile, (u_char *)tif->tif_rawdata, bytecount, module) != bytecount) return (0); if (!isFillOrder(tif, td->td_fillorder) && (tif->tif_flags & TIFF_NOBITREV) == 0) TIFFReverseBits(tif->tif_rawdata, bytecount); } return (TIFFStartTile(tif, tile)); } /* * Setup the raw data buffer in preparation for * reading a strip of raw data. If the buffer * is specified as zero, then a buffer of appropriate * size is allocated by the library. Otherwise, * the client must guarantee that the buffer is * large enough to hold any individual strip of * raw data. */ int TIFFReadBufferSetup(TIFF* tif, tdata_t bp, tsize_t size) { static const char module[] = "TIFFReadBufferSetup"; if (tif->tif_rawdata) { if (tif->tif_flags & TIFF_MYBUFFER) _TIFFfree(tif->tif_rawdata); tif->tif_rawdata = NULL; } if (bp) { tif->tif_rawdatasize = size; tif->tif_rawdata = (tidata_t) bp; tif->tif_flags &= ~TIFF_MYBUFFER; } else { tif->tif_rawdatasize = TIFFroundup(size, 1024); tif->tif_rawdata = (tidata_t) _TIFFmalloc(tif->tif_rawdatasize); tif->tif_flags |= TIFF_MYBUFFER; } if (tif->tif_rawdata == NULL) { TIFFError(module, "%s: No space for data buffer at scanline %ld", tif->tif_name, (long) tif->tif_row); tif->tif_rawdatasize = 0; return (0); } return (1); } /* * Set state to appear as if a * strip has just been read in. */ static int TIFFStartStrip(TIFF* tif, tstrip_t strip) { TIFFDirectory *td = &tif->tif_dir; if ((tif->tif_flags & TIFF_CODERSETUP) == 0) { if (!(*tif->tif_setupdecode)(tif)) return (0); tif->tif_flags |= TIFF_CODERSETUP; } tif->tif_curstrip = strip; tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip; tif->tif_rawcp = tif->tif_rawdata; tif->tif_rawcc = td->td_stripbytecount[strip]; return ((*tif->tif_predecode)(tif, (tsample_t)(strip / td->td_stripsperimage))); } /* * Set state to appear as if a * tile has just been read in. */ static int TIFFStartTile(TIFF* tif, ttile_t tile) { TIFFDirectory *td = &tif->tif_dir; if ((tif->tif_flags & TIFF_CODERSETUP) == 0) { if (!(*tif->tif_setupdecode)(tif)) return (0); tif->tif_flags |= TIFF_CODERSETUP; } tif->tif_curtile = tile; tif->tif_row = (tile % TIFFhowmany(td->td_imagewidth, td->td_tilewidth)) * td->td_tilelength; tif->tif_col = (tile % TIFFhowmany(td->td_imagelength, td->td_tilelength)) * td->td_tilewidth; tif->tif_rawcp = tif->tif_rawdata; tif->tif_rawcc = td->td_stripbytecount[tile]; return ((*tif->tif_predecode)(tif, (tsample_t)(tile/td->td_stripsperimage))); } static int TIFFCheckRead(TIFF* tif, int tiles) { if (tif->tif_mode == O_WRONLY) { TIFFError(tif->tif_name, "File not open for reading"); return (0); } if (tiles ^ isTiled(tif)) { TIFFError(tif->tif_name, tiles ? "Can not read tiles from a stripped image" : "Can not read scanlines from a tiled image"); return (0); } return (1); } void _TIFFNoPostDecode(TIFF* tif, tidata_t buf, tsize_t cc) { (void) tif; (void) buf; (void) cc; } void _TIFFSwab16BitData(TIFF* tif, tidata_t buf, tsize_t cc) { (void) tif; assert((cc & 1) == 0); TIFFSwabArrayOfShort((uint16*) buf, cc/2); } void _TIFFSwab32BitData(TIFF* tif, tidata_t buf, tsize_t cc) { (void) tif; assert((cc & 3) == 0); TIFFSwabArrayOfLong((uint32*) buf, cc/4); } void _TIFFSwab64BitData(TIFF* tif, tidata_t buf, tsize_t cc) { (void) tif; assert((cc & 7) == 0); TIFFSwabArrayOfDouble((double*) buf, cc/8); } netpbm-8.2/libtiff/tif_strip.c0100660000076400000000000001307106747424643015476 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_strip.c,v 1.1.1.1 1999/07/27 21:50:27 mike Exp $ */ /* * Copyright (c) 1991-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library. * * Strip-organized Image Support Routines. */ #include "tiffiop.h" /* * Compute which strip a (row,sample) value is in. */ tstrip_t TIFFComputeStrip(TIFF* tif, uint32 row, tsample_t sample) { TIFFDirectory *td = &tif->tif_dir; tstrip_t strip; strip = row / td->td_rowsperstrip; if (td->td_planarconfig == PLANARCONFIG_SEPARATE) { if (sample >= td->td_samplesperpixel) { TIFFError(tif->tif_name, "%u: Sample out of range, max %u", sample, td->td_samplesperpixel); return ((tstrip_t) 0); } strip += sample*td->td_stripsperimage; } return (strip); } /* * Compute how many strips are in an image. */ tstrip_t TIFFNumberOfStrips(TIFF* tif) { TIFFDirectory *td = &tif->tif_dir; tstrip_t nstrips; nstrips = (td->td_rowsperstrip == (uint32) -1 ? (td->td_imagelength != 0 ? 1 : 0) : TIFFhowmany(td->td_imagelength, td->td_rowsperstrip)); if (td->td_planarconfig == PLANARCONFIG_SEPARATE) nstrips *= td->td_samplesperpixel; return (nstrips); } /* * Compute the # bytes in a variable height, row-aligned strip. */ tsize_t TIFFVStripSize(TIFF* tif, uint32 nrows) { TIFFDirectory *td = &tif->tif_dir; if (nrows == (uint32) -1) nrows = td->td_imagelength; #ifdef YCBCR_SUPPORT if (td->td_planarconfig == PLANARCONFIG_CONTIG && td->td_photometric == PHOTOMETRIC_YCBCR && !isUpSampled(tif)) { /* * Packed YCbCr data contain one Cb+Cr for every * HorizontalSampling*VerticalSampling Y values. * Must also roundup width and height when calculating * since images that are not a multiple of the * horizontal/vertical subsampling area include * YCbCr data for the extended image. */ tsize_t w = TIFFroundup(td->td_imagewidth, td->td_ycbcrsubsampling[0]); tsize_t scanline = TIFFhowmany(w*td->td_bitspersample, 8); tsize_t samplingarea = td->td_ycbcrsubsampling[0]*td->td_ycbcrsubsampling[1]; nrows = TIFFroundup(nrows, td->td_ycbcrsubsampling[1]); /* NB: don't need TIFFhowmany here 'cuz everything is rounded */ return ((tsize_t) (nrows*scanline + 2*(nrows*scanline / samplingarea))); } else #endif return ((tsize_t)(nrows * TIFFScanlineSize(tif))); } /* * Compute the # bytes in a (row-aligned) strip. * * Note that if RowsPerStrip is larger than the * recorded ImageLength, then the strip size is * truncated to reflect the actual space required * to hold the strip. */ tsize_t TIFFStripSize(TIFF* tif) { TIFFDirectory* td = &tif->tif_dir; uint32 rps = td->td_rowsperstrip; if (rps > td->td_imagelength) rps = td->td_imagelength; return (TIFFVStripSize(tif, rps)); } /* * Compute a default strip size based on the image * characteristics and a requested value. If the * request is <1 then we choose a strip size according * to certain heuristics. */ uint32 TIFFDefaultStripSize(TIFF* tif, uint32 request) { return (*tif->tif_defstripsize)(tif, request); } uint32 _TIFFDefaultStripSize(TIFF* tif, uint32 s) { if ((int32) s < 1) { /* * If RowsPerStrip is unspecified, try to break the * image up into strips that are approximately 8Kbytes. */ tsize_t scanline = TIFFScanlineSize(tif); s = (uint32)(8*1024) / (scanline == 0 ? 1 : scanline); if (s == 0) /* very wide images */ s = 1; } return (s); } /* * Return the number of bytes to read/write in a call to * one of the scanline-oriented i/o routines. Note that * this number may be 1/samples-per-pixel if data is * stored as separate planes. */ tsize_t TIFFScanlineSize(TIFF* tif) { TIFFDirectory *td = &tif->tif_dir; tsize_t scanline; scanline = td->td_bitspersample * td->td_imagewidth; if (td->td_planarconfig == PLANARCONFIG_CONTIG) scanline *= td->td_samplesperpixel; return ((tsize_t) TIFFhowmany(scanline, 8)); } /* * Return the number of bytes required to store a complete * decoded and packed raster scanline (as opposed to the * I/O size returned by TIFFScanlineSize which may be less * if data is store as separate planes). */ tsize_t TIFFRasterScanlineSize(TIFF* tif) { TIFFDirectory *td = &tif->tif_dir; tsize_t scanline; scanline = td->td_bitspersample * td->td_imagewidth; if (td->td_planarconfig == PLANARCONFIG_CONTIG) { scanline *= td->td_samplesperpixel; return ((tsize_t) TIFFhowmany(scanline, 8)); } else return ((tsize_t) TIFFhowmany(scanline, 8)*td->td_samplesperpixel); } netpbm-8.2/libtiff/tif_swab.c0100660000076400000000000001606506747424643015277 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_swab.c,v 1.1.1.1 1999/07/27 21:50:27 mike Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library Bit & Byte Swapping Support. * * XXX We assume short = 16-bits and long = 32-bits XXX */ #include "tiffiop.h" #ifndef TIFFSwabShort void TIFFSwabShort(uint16* wp) { register u_char* cp = (u_char*) wp; int t; t = cp[1]; cp[1] = cp[0]; cp[0] = t; } #endif #ifndef TIFFSwabLong void TIFFSwabLong(uint32* lp) { register u_char* cp = (u_char*) lp; int t; t = cp[3]; cp[3] = cp[0]; cp[0] = t; t = cp[2]; cp[2] = cp[1]; cp[1] = t; } #endif #ifndef TIFFSwabArrayOfShort void TIFFSwabArrayOfShort(uint16* wp, register u_long n) { register u_char* cp; register int t; /* XXX unroll loop some */ while (n-- > 0) { cp = (u_char*) wp; t = cp[1]; cp[1] = cp[0]; cp[0] = t; wp++; } } #endif #ifndef TIFFSwabArrayOfLong void TIFFSwabArrayOfLong(register uint32* lp, register u_long n) { register unsigned char *cp; register int t; /* XXX unroll loop some */ while (n-- > 0) { cp = (unsigned char *)lp; t = cp[3]; cp[3] = cp[0]; cp[0] = t; t = cp[2]; cp[2] = cp[1]; cp[1] = t; lp++; } } #endif #ifndef TIFFSwabDouble void TIFFSwabDouble(double *dp) { register uint32* lp = (uint32*) dp; uint32 t; TIFFSwabArrayOfLong(lp, 2); t = lp[0]; lp[0] = lp[1]; lp[1] = t; } #endif #ifndef TIFFSwabArrayOfDouble void TIFFSwabArrayOfDouble(double* dp, register u_long n) { register uint32* lp = (uint32*) dp; register uint32 t; TIFFSwabArrayOfLong(lp, n + n); while (n-- > 0) { t = lp[0]; lp[0] = lp[1]; lp[1] = t; lp += 2; } } #endif /* * Bit reversal tables. TIFFBitRevTable[] gives * the bit reversed value of . Used in various * places in the library when the FillOrder requires * bit reversal of byte values (e.g. CCITT Fax 3 * encoding/decoding). TIFFNoBitRevTable is provided * for algorithms that want an equivalent table that * do not reverse bit values. */ static const unsigned char TIFFBitRevTable[256] = { 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0, 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8, 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8, 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4, 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc, 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2, 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea, 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa, 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6, 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe, 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1, 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1, 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9, 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5, 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5, 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed, 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd, 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3, 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb, 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb, 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7, 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7, 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff }; static const unsigned char TIFFNoBitRevTable[256] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, }; const unsigned char* TIFFGetBitRevTable(int reversed) { return (reversed ? TIFFBitRevTable : TIFFNoBitRevTable); } void TIFFReverseBits(register u_char* cp, register u_long n) { for (; n > 8; n -= 8) { cp[0] = TIFFBitRevTable[cp[0]]; cp[1] = TIFFBitRevTable[cp[1]]; cp[2] = TIFFBitRevTable[cp[2]]; cp[3] = TIFFBitRevTable[cp[3]]; cp[4] = TIFFBitRevTable[cp[4]]; cp[5] = TIFFBitRevTable[cp[5]]; cp[6] = TIFFBitRevTable[cp[6]]; cp[7] = TIFFBitRevTable[cp[7]]; cp += 8; } while (n-- > 0) *cp = TIFFBitRevTable[*cp], cp++; } netpbm-8.2/libtiff/tif_thunder.c0100660000076400000000000001134306747424643016006 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_thunder.c,v 1.1.1.1 1999/07/27 21:50:27 mike Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #include "tiffiop.h" #ifdef THUNDER_SUPPORT /* * TIFF Library. * * ThunderScan 4-bit Compression Algorithm Support */ /* * ThunderScan uses an encoding scheme designed for * 4-bit pixel values. Data is encoded in bytes, with * each byte split into a 2-bit code word and a 6-bit * data value. The encoding gives raw data, runs of * pixels, or pixel values encoded as a delta from the * previous pixel value. For the latter, either 2-bit * or 3-bit delta values are used, with the deltas packed * into a single byte. */ #define THUNDER_DATA 0x3f /* mask for 6-bit data */ #define THUNDER_CODE 0xc0 /* mask for 2-bit code word */ /* code values */ #define THUNDER_RUN 0x00 /* run of pixels w/ encoded count */ #define THUNDER_2BITDELTAS 0x40 /* 3 pixels w/ encoded 2-bit deltas */ #define DELTA2_SKIP 2 /* skip code for 2-bit deltas */ #define THUNDER_3BITDELTAS 0x80 /* 2 pixels w/ encoded 3-bit deltas */ #define DELTA3_SKIP 4 /* skip code for 3-bit deltas */ #define THUNDER_RAW 0xc0 /* raw data encoded */ static const int twobitdeltas[4] = { 0, 1, 0, -1 }; static const int threebitdeltas[8] = { 0, 1, 2, 3, 0, -3, -2, -1 }; #define SETPIXEL(op, v) { \ lastpixel = (v) & 0xf; \ if (npixels++ & 1) \ *op++ |= lastpixel; \ else \ op[0] = lastpixel << 4; \ } static int ThunderDecode(TIFF* tif, tidata_t op, tsize_t maxpixels) { register u_char *bp; register tsize_t cc; u_int lastpixel; tsize_t npixels; bp = (u_char *)tif->tif_rawcp; cc = tif->tif_rawcc; lastpixel = 0; npixels = 0; while (cc > 0 && npixels < maxpixels) { int n, delta; n = *bp++, cc--; switch (n & THUNDER_CODE) { case THUNDER_RUN: /* pixel run */ /* * Replicate the last pixel n times, * where n is the lower-order 6 bits. */ if (npixels & 1) { op[0] |= lastpixel; lastpixel = *op++; npixels++; n--; } else lastpixel |= lastpixel << 4; npixels += n; for (; n > 0; n -= 2) *op++ = lastpixel; if (n == -1) *--op &= 0xf0; lastpixel &= 0xf; break; case THUNDER_2BITDELTAS: /* 2-bit deltas */ if ((delta = ((n >> 4) & 3)) != DELTA2_SKIP) SETPIXEL(op, lastpixel + twobitdeltas[delta]); if ((delta = ((n >> 2) & 3)) != DELTA2_SKIP) SETPIXEL(op, lastpixel + twobitdeltas[delta]); if ((delta = (n & 3)) != DELTA2_SKIP) SETPIXEL(op, lastpixel + twobitdeltas[delta]); break; case THUNDER_3BITDELTAS: /* 3-bit deltas */ if ((delta = ((n >> 3) & 7)) != DELTA3_SKIP) SETPIXEL(op, lastpixel + threebitdeltas[delta]); if ((delta = (n & 7)) != DELTA3_SKIP) SETPIXEL(op, lastpixel + threebitdeltas[delta]); break; case THUNDER_RAW: /* raw data */ SETPIXEL(op, n); break; } } tif->tif_rawcp = (tidata_t) bp; tif->tif_rawcc = cc; if (npixels != maxpixels) { TIFFError(tif->tif_name, "ThunderDecode: %s data at scanline %ld (%lu != %lu)", npixels < maxpixels ? "Not enough" : "Too much", (long) tif->tif_row, (long) npixels, (long) maxpixels); return (0); } return (1); } static int ThunderDecodeRow(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s) { tidata_t row = buf; (void) s; while ((long)occ > 0) { if (!ThunderDecode(tif, row, tif->tif_dir.td_imagewidth)) return (0); occ -= tif->tif_scanlinesize; row += tif->tif_scanlinesize; } return (1); } int TIFFInitThunderScan(TIFF* tif, int scheme) { (void) scheme; tif->tif_decoderow = ThunderDecodeRow; tif->tif_decodestrip = ThunderDecodeRow; return (1); } #endif /* THUNDER_SUPPORT */ netpbm-8.2/libtiff/tif_tile.c0100660000076400000000000001412006747424643015266 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_tile.c,v 1.1.1.1 1999/07/27 21:50:27 mike Exp $ */ /* * Copyright (c) 1991-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library. * * Tiled Image Support Routines. */ #include "tiffiop.h" /* * Compute which tile an (x,y,z,s) value is in. */ ttile_t TIFFComputeTile(TIFF* tif, uint32 x, uint32 y, uint32 z, tsample_t s) { TIFFDirectory *td = &tif->tif_dir; uint32 dx = td->td_tilewidth; uint32 dy = td->td_tilelength; uint32 dz = td->td_tiledepth; ttile_t tile = 1; if (td->td_imagedepth == 1) z = 0; if (dx == (uint32) -1) dx = td->td_imagewidth; if (dy == (uint32) -1) dy = td->td_imagelength; if (dz == (uint32) -1) dz = td->td_imagedepth; if (dx != 0 && dy != 0 && dz != 0) { uint32 xpt = TIFFhowmany(td->td_imagewidth, dx); uint32 ypt = TIFFhowmany(td->td_imagelength, dy); uint32 zpt = TIFFhowmany(td->td_imagedepth, dz); if (td->td_planarconfig == PLANARCONFIG_SEPARATE) tile = (xpt*ypt*zpt)*s + (xpt*ypt)*(z/dz) + xpt*(y/dy) + x/dx; else tile = (xpt*ypt)*(z/dz) + xpt*(y/dy) + x/dx + s; } return (tile); } /* * Check an (x,y,z,s) coordinate * against the image bounds. */ int TIFFCheckTile(TIFF* tif, uint32 x, uint32 y, uint32 z, tsample_t s) { TIFFDirectory *td = &tif->tif_dir; if (x >= td->td_imagewidth) { TIFFError(tif->tif_name, "Col %ld out of range, max %lu", (long) x, (u_long) td->td_imagewidth); return (0); } if (y >= td->td_imagelength) { TIFFError(tif->tif_name, "Row %ld out of range, max %lu", (long) y, (u_long) td->td_imagelength); return (0); } if (z >= td->td_imagedepth) { TIFFError(tif->tif_name, "Depth %ld out of range, max %lu", (long) z, (u_long) td->td_imagedepth); return (0); } if (td->td_planarconfig == PLANARCONFIG_SEPARATE && s >= td->td_samplesperpixel) { TIFFError(tif->tif_name, "Sample %d out of range, max %u", (int) s, td->td_samplesperpixel); return (0); } return (1); } /* * Compute how many tiles are in an image. */ ttile_t TIFFNumberOfTiles(TIFF* tif) { TIFFDirectory *td = &tif->tif_dir; uint32 dx = td->td_tilewidth; uint32 dy = td->td_tilelength; uint32 dz = td->td_tiledepth; ttile_t ntiles; if (dx == (uint32) -1) dx = td->td_imagewidth; if (dy == (uint32) -1) dy = td->td_imagelength; if (dz == (uint32) -1) dz = td->td_imagedepth; ntiles = (dx == 0 || dy == 0 || dz == 0) ? 0 : (TIFFhowmany(td->td_imagewidth, dx) * TIFFhowmany(td->td_imagelength, dy) * TIFFhowmany(td->td_imagedepth, dz)); if (td->td_planarconfig == PLANARCONFIG_SEPARATE) ntiles *= td->td_samplesperpixel; return (ntiles); } /* * Compute the # bytes in each row of a tile. */ tsize_t TIFFTileRowSize(TIFF* tif) { TIFFDirectory *td = &tif->tif_dir; tsize_t rowsize; if (td->td_tilelength == 0 || td->td_tilewidth == 0) return ((tsize_t) 0); rowsize = td->td_bitspersample * td->td_tilewidth; if (td->td_planarconfig == PLANARCONFIG_CONTIG) rowsize *= td->td_samplesperpixel; return ((tsize_t) TIFFhowmany(rowsize, 8)); } /* * Compute the # bytes in a variable length, row-aligned tile. */ tsize_t TIFFVTileSize(TIFF* tif, uint32 nrows) { TIFFDirectory *td = &tif->tif_dir; tsize_t tilesize; if (td->td_tilelength == 0 || td->td_tilewidth == 0 || td->td_tiledepth == 0) return ((tsize_t) 0); #ifdef YCBCR_SUPPORT if (td->td_planarconfig == PLANARCONFIG_CONTIG && td->td_photometric == PHOTOMETRIC_YCBCR && !isUpSampled(tif)) { /* * Packed YCbCr data contain one Cb+Cr for every * HorizontalSampling*VerticalSampling Y values. * Must also roundup width and height when calculating * since images that are not a multiple of the * horizontal/vertical subsampling area include * YCbCr data for the extended image. */ tsize_t w = TIFFroundup(td->td_tilewidth, td->td_ycbcrsubsampling[0]); tsize_t rowsize = TIFFhowmany(w*td->td_bitspersample, 8); tsize_t samplingarea = td->td_ycbcrsubsampling[0]*td->td_ycbcrsubsampling[1]; nrows = TIFFroundup(nrows, td->td_ycbcrsubsampling[1]); /* NB: don't need TIFFhowmany here 'cuz everything is rounded */ tilesize = nrows*rowsize + 2*(nrows*rowsize / samplingarea); } else #endif tilesize = nrows * TIFFTileRowSize(tif); return ((tsize_t)(tilesize * td->td_tiledepth)); } /* * Compute the # bytes in a row-aligned tile. */ tsize_t TIFFTileSize(TIFF* tif) { return (TIFFVTileSize(tif, tif->tif_dir.td_tilelength)); } /* * Compute a default tile size based on the image * characteristics and a requested value. If a * request is <1 then we choose a size according * to certain heuristics. */ void TIFFDefaultTileSize(TIFF* tif, uint32* tw, uint32* th) { (*tif->tif_deftilesize)(tif, tw, th); } void _TIFFDefaultTileSize(TIFF* tif, uint32* tw, uint32* th) { (void) tif; if (*(int32*) tw < 1) *tw = 256; if (*(int32*) th < 1) *th = 256; /* roundup to a multiple of 16 per the spec */ if (*tw & 0xf) *tw = TIFFroundup(*tw, 16); if (*th & 0xf) *th = TIFFroundup(*th, 16); } netpbm-8.2/libtiff/tif_unix.c0100660000076400000000000001123606772565150015316 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_unix.c,v 1.2 1999/09/24 03:05:12 warmerda Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library UNIX-specific Routines. */ #include "tiffiop.h" #include #include #include static tsize_t _tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size) { return ((tsize_t) read((int) fd, buf, (size_t) size)); } static tsize_t _tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size) { return ((tsize_t) write((int) fd, buf, (size_t) size)); } static toff_t _tiffSeekProc(thandle_t fd, toff_t off, int whence) { return ((toff_t) lseek((int) fd, (off_t) off, whence)); } static int _tiffCloseProc(thandle_t fd) { return (close((int) fd)); } #include static toff_t _tiffSizeProc(thandle_t fd) { #ifdef _AM29K long fsize; return ((fsize = lseek((int) fd, 0, SEEK_END)) < 0 ? 0 : fsize); #else struct stat sb; return (toff_t) (fstat((int) fd, &sb) < 0 ? 0 : sb.st_size); #endif } #ifdef HAVE_MMAP #include static int _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) { toff_t size = _tiffSizeProc(fd); if (size != (toff_t) -1) { *pbase = (tdata_t) mmap(0, size, PROT_READ, MAP_SHARED, (int) fd, 0); if (*pbase != (tdata_t) -1) { *psize = size; return (1); } } return (0); } static void _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size) { (void) fd; (void) munmap(base, (off_t) size); } #else /* !HAVE_MMAP */ static int _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) { (void) fd; (void) pbase; (void) psize; return (0); } static void _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size) { (void) fd; (void) base; (void) size; } #endif /* !HAVE_MMAP */ /* * Open a TIFF file descriptor for read/writing. */ TIFF* TIFFFdOpen(int fd, const char* name, const char* mode) { TIFF* tif; tif = TIFFClientOpen(name, mode, (thandle_t) fd, _tiffReadProc, _tiffWriteProc, _tiffSeekProc, _tiffCloseProc, _tiffSizeProc, _tiffMapProc, _tiffUnmapProc); if (tif) tif->tif_fd = fd; return (tif); } /* * Open a TIFF file for read/writing. */ TIFF* TIFFOpen(const char* name, const char* mode) { static const char module[] = "TIFFOpen"; int m, fd; m = _TIFFgetMode(mode, module); if (m == -1) return ((TIFF*)0); /* for cygwin */ #ifdef O_BINARY m |= O_BINARY; #endif #ifdef _AM29K fd = open(name, m); #else fd = open(name, m, 0666); #endif if (fd < 0) { TIFFError(module, "%s: Cannot open", name); return ((TIFF *)0); } return (TIFFFdOpen(fd, name, mode)); } void* _TIFFmalloc(tsize_t s) { return (malloc((size_t) s)); } void _TIFFfree(tdata_t p) { free(p); } void* _TIFFrealloc(tdata_t p, tsize_t s) { return (realloc(p, (size_t) s)); } void _TIFFmemset(tdata_t p, int v, tsize_t c) { memset(p, v, (size_t) c); } void _TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c) { memcpy(d, s, (size_t) c); } int _TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c) { return (memcmp(p1, p2, (size_t) c)); } static void unixWarningHandler(const char* module, const char* fmt, va_list ap) { if (module != NULL) fprintf(stderr, "%s: ", module); fprintf(stderr, "Warning, "); vfprintf(stderr, fmt, ap); fprintf(stderr, ".\n"); } TIFFErrorHandler _TIFFwarningHandler = unixWarningHandler; static void unixErrorHandler(const char* module, const char* fmt, va_list ap) { if (module != NULL) fprintf(stderr, "%s: ", module); vfprintf(stderr, fmt, ap); fprintf(stderr, ".\n"); } TIFFErrorHandler _TIFFerrorHandler = unixErrorHandler; netpbm-8.2/libtiff/tif_version.c0100660000076400000000000000266606747424643016032 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_version.c,v 1.1.1.1 1999/07/27 21:50:27 mike Exp $ */ /* * Copyright (c) 1992-1997 Sam Leffler * Copyright (c) 1992-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. */ #include "tiffiop.h" #include "version.h" static const char TIFFVersion[] = VERSION; const char* TIFFGetVersion(void) { return (TIFFVersion); } netpbm-8.2/libtiff/tif_vms.c0100660000076400000000000003273006747424643015145 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_vms.c,v 1.1.1.1 1999/07/27 21:50:27 mike Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library VMS-specific Routines. */ #include #include #include "tiffiop.h" #if !HAVE_IEEEFP #include #endif #ifdef VAXC #define NOSHARE noshare #else #define NOSHARE #endif #ifdef __alpha /* Dummy entry point for backwards compatibility */ void TIFFModeCCITTFax3(void){} #endif static tsize_t _tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size) { return (read((int) fd, buf, size)); } static tsize_t _tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size) { return (write((int) fd, buf, size)); } static toff_t _tiffSeekProc(thandle_t fd, toff_t off, int whence) { return ((toff_t) lseek((int) fd, (off_t) off, whence)); } static int _tiffCloseProc(thandle_t fd) { return (close((int) fd)); } #include static toff_t _tiffSizeProc(thandle_t fd) { struct stat sb; return (toff_t) (fstat((int) fd, &sb) < 0 ? 0 : sb.st_size); } #ifdef HAVE_MMAP #include #include #include /* * Table for storing information on current open sections. * (Should really be a linked list) */ #define MAX_MAPPED 100 static int no_mapped = 0; static struct { char *base; char *top; unsigned short channel; } map_table[MAX_MAPPED]; /* * This routine maps a file into a private section. Note that this * method of accessing a file is by far the fastest under VMS. * The routine may fail (i.e. return 0) for several reasons, for * example: * - There is no more room for storing the info on sections. * - The process is out of open file quota, channels, ... * - fd does not describe an opened file. * - The file is already opened for write access by this process * or another process * - There is no free "hole" in virtual memory that fits the * size of the file */ static int _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) { char name[256]; struct FAB fab; unsigned short channel; char *inadr[2], *retadr[2]; unsigned long status; long size; if (no_mapped >= MAX_MAPPED) return(0); /* * We cannot use a file descriptor, we * must open the file once more. */ if (getname((int)fd, name, 1) == NULL) return(0); /* prepare the FAB for a user file open */ fab = cc$rms_fab; fab.fab$l_fop |= FAB$V_UFO; fab.fab$b_fac = FAB$M_GET; fab.fab$b_shr = FAB$M_SHRGET; fab.fab$l_fna = name; fab.fab$b_fns = strlen(name); status = sys$open(&fab); /* open file & get channel number */ if ((status&1) == 0) return(0); channel = (unsigned short)fab.fab$l_stv; inadr[0] = inadr[1] = (char *)0; /* just an address in P0 space */ /* * Map the blocks of the file up to * the EOF block into virtual memory. */ size = _tiffSizeProc(fd); status = sys$crmpsc(inadr, retadr, 0, SEC$M_EXPREG, 0,0,0, channel, TIFFhowmany(size,512), 0,0,0); if ((status&1) == 0){ sys$dassgn(channel); return(0); } *pbase = (tdata_t) retadr[0]; /* starting virtual address */ /* * Use the size of the file up to the * EOF mark for UNIX compatibility. */ *psize = (toff_t) size; /* Record the section in the table */ map_table[no_mapped].base = retadr[0]; map_table[no_mapped].top = retadr[1]; map_table[no_mapped].channel = channel; no_mapped++; return(1); } /* * This routine unmaps a section from the virtual address space of * the process, but only if the base was the one returned from a * call to TIFFMapFileContents. */ static void _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size) { char *inadr[2]; int i, j; /* Find the section in the table */ for (i = 0;i < no_mapped; i++) { if (map_table[i].base == (char *) base) { /* Unmap the section */ inadr[0] = (char *) base; inadr[1] = map_table[i].top; sys$deltva(inadr, 0, 0); sys$dassgn(map_table[i].channel); /* Remove this section from the list */ for (j = i+1; j < no_mapped; j++) map_table[j-1] = map_table[j]; no_mapped--; return; } } } #else /* !HAVE_MMAP */ static int _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) { return (0); } static void _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size) { } #endif /* !HAVE_MMAP */ /* * Open a TIFF file descriptor for read/writing. */ TIFF* TIFFFdOpen(int fd, const char* name, const char* mode) { TIFF* tif; tif = TIFFClientOpen(name, mode, (thandle_t) fd, _tiffReadProc, _tiffWriteProc, _tiffSeekProc, _tiffCloseProc, _tiffSizeProc, _tiffMapProc, _tiffUnmapProc); if (tif) tif->tif_fd = fd; return (tif); } /* * Open a TIFF file for read/writing. */ TIFF* TIFFOpen(const char* name, const char* mode) { static const char module[] = "TIFFOpen"; int m, fd; m = _TIFFgetMode(mode, module); if (m == -1) return ((TIFF*)0); if (m&O_TRUNC){ /* * There is a bug in open in VAXC. If you use * open w/ m=O_RDWR|O_CREAT|O_TRUNC the * wrong thing happens. On the other hand * creat does the right thing. */ fd = creat((char *) /* bug in stdio.h */ name, 0666, "alq = 128", "deq = 64", "mbc = 32", "fop = tef"); } else if (m&O_RDWR) { fd = open(name, m, 0666, "deq = 64", "mbc = 32", "fop = tef", "ctx = stm"); } else fd = open(name, m, 0666, "mbc = 32", "ctx = stm"); if (fd < 0) { TIFFError(module, "%s: Cannot open", name); return ((TIFF*)0); } return (TIFFFdOpen(fd, name, mode)); } tdata_t _TIFFmalloc(tsize_t s) { return (malloc((size_t) s)); } void _TIFFfree(tdata_t p) { free(p); } tdata_t _TIFFrealloc(tdata_t p, tsize_t s) { return (realloc(p, (size_t) s)); } void _TIFFmemset(tdata_t p, int v, tsize_t c) { memset(p, v, (size_t) c); } void _TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c) { memcpy(d, s, (size_t) c); } int _TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c) { return (memcmp(p1, p2, (size_t) c)); } /* * On the VAX, we need to make those global, writable pointers * non-shareable, otherwise they would be made shareable by default. * On the AXP, this brain damage has been corrected. * * I (Karsten Spang, krs@kampsax.dk) have dug around in the GCC * manual and the GAS code and have come up with the following * construct, but I don't have GCC on my VAX, so it is untested. * Please tell me if it does not work. */ static void vmsWarningHandler(const char* module, const char* fmt, va_list ap) { if (module != NULL) fprintf(stderr, "%s: ", module); fprintf(stderr, "Warning, "); vfprintf(stderr, fmt, ap); fprintf(stderr, ".\n"); } NOSHARE TIFFErrorHandler _TIFFwarningHandler = vmsWarningHandler #if defined(VAX) && defined(__GNUC__) asm("_$$PsectAttributes_NOSHR$$_TIFFwarningHandler") #endif ; static void vmsErrorHandler(const char* module, const char* fmt, va_list ap) { if (module != NULL) fprintf(stderr, "%s: ", module); vfprintf(stderr, fmt, ap); fprintf(stderr, ".\n"); } NOSHARE TIFFErrorHandler _TIFFerrorHandler = vmsErrorHandler #if defined(VAX) && defined(__GNUC__) asm("_$$PsectAttributes_NOSHR$$_TIFFerrorHandler") #endif ; #if !HAVE_IEEEFP /* IEEE floting point handling */ typedef struct ieeedouble { u_long mant2; /* fix NDR: full 8-byte swap */ u_long mant : 20, exp : 11, sign : 1; } ieeedouble; typedef struct ieeefloat { u_long mant : 23, exp : 8, sign : 1; } ieeefloat; /* * NB: These are D_FLOAT's, not G_FLOAT's. A G_FLOAT is * simply a reverse-IEEE float/double. */ typedef struct { u_long mant1 : 7, exp : 8, sign : 1, mant2 : 16, mant3 : 16, mant4 : 16; } nativedouble; typedef struct { u_long mant1 : 7, exp : 8, sign : 1, mant2 : 16; } nativefloat; typedef union { ieeedouble ieee; nativedouble native; char b[8]; uint32 l[2]; double d; } double_t; typedef union { ieeefloat ieee; nativefloat native; char b[4]; uint32 l; float f; } float_t; #if defined(VAXC) || defined(DECC) #pragma inline(ieeetod,dtoieee) #endif /* * Convert an IEEE double precision number to native double precision. * The source is contained in two longwords, the second holding the sign, * exponent and the higher order bits of the mantissa, and the first * holding the rest of the mantissa as follows: * (Note: It is assumed that the number has been eight-byte swapped to * LSB first.) * * First longword: * 32 least significant bits of mantissa * Second longword: * 0-19: 20 most significant bits of mantissa * 20-30: exponent * 31: sign * The exponent is stored as excess 1023. * The most significant bit of the mantissa is implied 1, and not stored. * If the exponent and mantissa are zero, the number is zero. * If the exponent is 0 (i.e. -1023) and the mantissa is non-zero, it is an * unnormalized number with the most significant bit NOT implied. * If the exponent is 2047, the number is invalid, in case the mantissa is zero, * this means overflow (+/- depending of the sign bit), otherwise * it simply means invalid number. * * If the number is too large for the machine or was specified as overflow, * +/-HUGE_VAL is returned. */ INLINE static void ieeetod(double *dp) { double_t source; long sign,exp,mant; double dmant; source.ieee = ((double_t*)dp)->ieee; sign = source.ieee.sign; exp = source.ieee.exp; mant = source.ieee.mant; if (exp == 2047) { if (mant) /* Not a Number (NAN) */ *dp = HUGE_VAL; else /* +/- infinity */ *dp = (sign ? -HUGE_VAL : HUGE_VAL); return; } if (!exp) { if (!(mant || source.ieee.mant2)) { /* zero */ *dp=0; return; } else { /* Unnormalized number */ /* NB: not -1023, the 1 bit is not implied */ exp= -1022; } } else { mant |= 1<<20; exp -= 1023; } dmant = (((double) mant) + ((double) source.ieee.mant2) / (((double) (1<<16)) * ((double) (1<<16)))) / (double) (1<<20); dmant = ldexp(dmant, exp); if (sign) dmant= -dmant; *dp = dmant; } INLINE static void dtoieee(double *dp) { double_t num; double x; int exp; num.d = *dp; if (!num.d) { /* Zero is just binary all zeros */ num.l[0] = num.l[1] = 0; return; } if (num.d < 0) { /* Sign is encoded separately */ num.d = -num.d; num.ieee.sign = 1; } else { num.ieee.sign = 0; } /* Now separate the absolute value into mantissa and exponent */ x = frexp(num.d, &exp); /* * Handle cases where the value is outside the * range for IEEE floating point numbers. * (Overflow cannot happen on a VAX, but underflow * can happen for G float.) */ if (exp < -1022) { /* Unnormalized number */ x = ldexp(x, -1023-exp); exp = 0; } else if (exp > 1023) { /* +/- infinity */ x = 0; exp = 2047; } else { /* Get rid of most significant bit */ x *= 2; x -= 1; exp += 1022; /* fix NDR: 1.0 -> x=0.5, exp=1 -> ieee.exp = 1023 */ } num.ieee.exp = exp; x *= (double) (1<<20); num.ieee.mant = (long) x; x -= (double) num.ieee.mant; num.ieee.mant2 = (long) (x*((double) (1<<16)*(double) (1<<16))); if (!(num.ieee.mant || num.ieee.exp || num.ieee.mant2)) { /* Avoid negative zero */ num.ieee.sign = 0; } ((double_t*)dp)->ieee = num.ieee; } /* * Beware, these do not handle over/under-flow * during conversion from ieee to native format. */ #define NATIVE2IEEEFLOAT(fp) { \ float_t t; \ if (t.ieee.exp = (fp)->native.exp) \ t.ieee.exp += -129 + 127; \ t.ieee.sign = (fp)->native.sign; \ t.ieee.mant = ((fp)->native.mant1<<16)|(fp)->native.mant2; \ *(fp) = t; \ } #define IEEEFLOAT2NATIVE(fp) { \ float_t t; int v = (fp)->ieee.exp; \ if (v) v += -127 + 129; /* alter bias of exponent */\ t.native.exp = v; /* implicit truncation of exponent */\ t.native.sign = (fp)->ieee.sign; \ v = (fp)->ieee.mant; \ t.native.mant1 = v >> 16; \ t.native.mant2 = v;\ *(fp) = t; \ } #define IEEEDOUBLE2NATIVE(dp) ieeetod(dp) #define NATIVE2IEEEDOUBLE(dp) dtoieee(dp) /* * These unions are used during floating point * conversions. The above macros define the * conversion operations. */ void TIFFCvtIEEEFloatToNative(TIFF* tif, u_int n, float* f) { float_t* fp = (float_t*) f; while (n-- > 0) { IEEEFLOAT2NATIVE(fp); fp++; } } void TIFFCvtNativeToIEEEFloat(TIFF* tif, u_int n, float* f) { float_t* fp = (float_t*) f; while (n-- > 0) { NATIVE2IEEEFLOAT(fp); fp++; } } void TIFFCvtIEEEDoubleToNative(TIFF* tif, u_int n, double* f) { double_t* fp = (double_t*) f; while (n-- > 0) { IEEEDOUBLE2NATIVE(fp); fp++; } } void TIFFCvtNativeToIEEEDouble(TIFF* tif, u_int n, double* f) { double_t* fp = (double_t*) f; while (n-- > 0) { NATIVE2IEEEDOUBLE(fp); fp++; } } #endif netpbm-8.2/libtiff/tif_warning.c0100660000076400000000000000326106747424643016002 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_warning.c,v 1.1.1.1 1999/07/27 21:50:27 mike Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library. */ #include "tiffiop.h" TIFFErrorHandler TIFFSetWarningHandler(TIFFErrorHandler handler) { TIFFErrorHandler prev = _TIFFwarningHandler; _TIFFwarningHandler = handler; return (prev); } void TIFFWarning(const char* module, const char* fmt, ...) { if (_TIFFwarningHandler) { va_list ap; va_start(ap, fmt); (*_TIFFwarningHandler)(module, fmt, ap); va_end(ap); } } netpbm-8.2/libtiff/tif_win3.c0100660000076400000000000001254706747424643015224 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_win3.c,v 1.1.1.1 1999/07/27 21:50:27 mike Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library Windows 3.x-specific Routines. */ #include "tiffiop.h" #if defined(__WATCOMC__) || defined(__BORLANDC__) || defined(_MSC_VER) #include /* for open, close, etc. function prototypes */ #endif #include #include #include static tsize_t _tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size) { return (_hread(fd, buf, size)); } static tsize_t _tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size) { return (_hwrite(fd, buf, size)); } static toff_t _tiffSeekProc(thandle_t fd, toff_t off, int whence) { return (_llseek(fd, (off_t) off, whence)); } static int _tiffCloseProc(thandle_t fd) { return (_lclose(fd)); } #include static toff_t _tiffSizeProc(thandle_t fd) { struct stat sb; return (fstat((int) fd, &sb) < 0 ? 0 : sb.st_size); } static int _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) { return (0); } static void _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size) { } /* * Open a TIFF file descriptor for read/writing. */ TIFF* TIFFFdOpen(int fd, const char* name, const char* mode) { TIFF* tif; tif = TIFFClientOpen(name, mode, (thandle_t) fd, _tiffReadProc, _tiffWriteProc, _tiffSeekProc, _tiffCloseProc, _tiffSizeProc, _tiffMapProc, _tiffUnmapProc); if (tif) tif->tif_fd = fd; return (tif); } /* * Open a TIFF file for read/writing. */ TIFF* TIFFOpen(const char* name, const char* mode) { static const char module[] = "TIFFOpen"; int m, fd; OFSTRUCT of; int mm = 0; m = _TIFFgetMode(mode, module); if (m == -1) return ((TIFF*)0); if (m & O_CREAT) { if ((m & O_TRUNC) || OpenFile(name, &of, OF_EXIST) != HFILE_ERROR) mm |= OF_CREATE; } if (m & O_WRONLY) mm |= OF_WRITE; if (m & O_RDWR) mm |= OF_READWRITE; fd = OpenFile(name, &of, mm); if (fd < 0) { TIFFError(module, "%s: Cannot open", name); return ((TIFF*)0); } return (TIFFFdOpen(fd, name, mode)); } tdata_t _TIFFmalloc(tsize_t s) { return (tdata_t) GlobalAllocPtr(GHND, (DWORD) s); } void _TIFFfree(tdata_t p) { GlobalFreePtr(p); } tdata_t _TIFFrealloc(tdata_t p, tsize_t s) { return (tdata_t) GlobalReAllocPtr(p, (DWORD) s, GHND); } void _TIFFmemset(tdata_t p, int v, tsize_t c) { char* pp = (char*) p; while (c > 0) { tsize_t chunk = 0x10000 - ((uint32) pp & 0xffff);/* What's left in segment */ if (chunk > 0xff00) /* No more than 0xff00 */ chunk = 0xff00; if (chunk > c) /* No more than needed */ chunk = c; memset(pp, v, chunk); pp = (char*) (chunk + (char huge*) pp); c -= chunk; } } void _TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c) { if (c > 0xFFFF) hmemcpy((void _huge*) d, (void _huge*) s, c); else (void) memcpy(d, s, (size_t) c); } int _TIFFmemcmp(const tdata_t d, const tdata_t s, tsize_t c) { char* dd = (char*) d; char* ss = (char*) s; tsize_t chunks, chunkd, chunk; int result; while (c > 0) { chunks = 0x10000 - ((uint32) ss & 0xffff); /* What's left in segment */ chunkd = 0x10000 - ((uint32) dd & 0xffff); /* What's left in segment */ chunk = c; /* Get the largest of */ if (chunk > chunks) /* c, chunks, chunkd, */ chunk = chunks; /* 0xff00 */ if (chunk > chunkd) chunk = chunkd; if (chunk > 0xff00) chunk = 0xff00; result = memcmp(dd, ss, chunk); if (result != 0) return (result); dd = (char*) (chunk + (char huge*) dd); ss = (char*) (chunk + (char huge*) ss); c -= chunk; } return (0); } static void win3WarningHandler(const char* module, const char* fmt, va_list ap) { char e[512] = { '\0' }; if (module != NULL) strcat(strcpy(e, module), ":"); vsprintf(e+strlen(e), fmt, ap); strcat(e, "."); MessageBox(GetActiveWindow(), e, "LibTIFF Warning", MB_OK|MB_ICONEXCLAMATION); } TIFFErrorHandler _TIFFwarningHandler = win3WarningHandler; static void win3ErrorHandler(const char* module, const char* fmt, va_list ap) { char e[512] = { '\0' }; if (module != NULL) strcat(strcpy(e, module), ":"); vsprintf(e+strlen(e), fmt, ap); strcat(e, "."); MessageBox(GetActiveWindow(), e, "LibTIFF Error", MB_OK|MB_ICONSTOP); } TIFFErrorHandler _TIFFerrorHandler = win3ErrorHandler; netpbm-8.2/libtiff/tif_win32.c0100660000076400000000000001700007020050237015246 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_win32.c,v 1.4 1999/11/27 21:43:59 warmerda Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library Win32-specific Routines. Adapted from tif_unix.c 4/5/95 by * Scott Wagner (wagner@itek.com), Itek Graphix, Rochester, NY USA */ #include #include "tiffiop.h" static tsize_t _tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size) { DWORD dwSizeRead; if (!ReadFile(fd, buf, size, &dwSizeRead, NULL)) return(0); return ((tsize_t) dwSizeRead); } static tsize_t _tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size) { DWORD dwSizeWritten; if (!WriteFile(fd, buf, size, &dwSizeWritten, NULL)) return(0); return ((tsize_t) dwSizeWritten); } static toff_t _tiffSeekProc(thandle_t fd, toff_t off, int whence) { DWORD dwMoveMethod; switch(whence) { case 0: dwMoveMethod = FILE_BEGIN; break; case 1: dwMoveMethod = FILE_CURRENT; break; case 2: dwMoveMethod = FILE_END; break; default: dwMoveMethod = FILE_BEGIN; break; } return ((toff_t)SetFilePointer(fd, off, NULL, dwMoveMethod)); } static int _tiffCloseProc(thandle_t fd) { return (CloseHandle(fd) ? 0 : -1); } static toff_t _tiffSizeProc(thandle_t fd) { return ((toff_t)GetFileSize(fd, NULL)); } #ifdef __BORLANDC__ #pragma argsused #endif static int _tiffDummyMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) { return (0); } /* * From "Hermann Josef Hill" : * * Windows uses both a handle and a pointer for file mapping, * but according to the SDK documentation and Richter's book * "Advanced Windows Programming" it is safe to free the handle * after obtaining the file mapping pointer * * This removes a nasty OS dependency and cures a problem * with Visual C++ 5.0 */ static int _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) { toff_t size; HANDLE hMapFile; if ((size = _tiffSizeProc(fd)) == (toff_t)-1) return (0); hMapFile = CreateFileMapping(fd, NULL, PAGE_READONLY, 0, size, NULL); if (hMapFile == NULL) return (0); *pbase = MapViewOfFile(hMapFile, FILE_MAP_READ, 0, 0, 0); CloseHandle(hMapFile); if (*pbase == NULL) return (0); *psize = size; return(1); } #ifdef __BORLANDC__ #pragma argsused #endif static void _tiffDummyUnmapProc(thandle_t fd, tdata_t base, toff_t size) { } static void _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size) { UnmapViewOfFile(base); } /* * Open a TIFF file descriptor for read/writing. * Note that TIFFFdOpen and TIFFOpen recognise the character 'u' in the mode * string, which forces the file to be opened unmapped. */ TIFF* TIFFFdOpen(int ifd, const char* name, const char* mode) { TIFF* tif; BOOL fSuppressMap = (mode[1] == 'u' || mode[2] == 'u'); tif = TIFFClientOpen(name, mode, (thandle_t)ifd, _tiffReadProc, _tiffWriteProc, _tiffSeekProc, _tiffCloseProc, _tiffSizeProc, fSuppressMap ? _tiffDummyMapProc : _tiffMapProc, fSuppressMap ? _tiffDummyUnmapProc : _tiffUnmapProc); if (tif) tif->tif_fd = ifd; return (tif); } /* * Open a TIFF file for read/writing. */ TIFF* TIFFOpen(const char* name, const char* mode) { static const char module[] = "TIFFOpen"; thandle_t fd; int m; DWORD dwMode; m = _TIFFgetMode(mode, module); switch(m) { case O_RDONLY: dwMode = OPEN_EXISTING; break; case O_RDWR: dwMode = OPEN_ALWAYS; break; case O_RDWR|O_CREAT: dwMode = OPEN_ALWAYS; break; case O_RDWR|O_TRUNC: dwMode = CREATE_ALWAYS; break; case O_RDWR|O_CREAT|O_TRUNC: dwMode = CREATE_ALWAYS; break; default: return ((TIFF*)0); } fd = (thandle_t)CreateFile(name, (m == O_RDONLY) ? GENERIC_READ : (GENERIC_READ | GENERIC_WRITE), FILE_SHARE_READ, NULL, dwMode, (m == O_RDONLY) ? FILE_ATTRIBUTE_READONLY : FILE_ATTRIBUTE_NORMAL, NULL); if (fd == INVALID_HANDLE_VALUE) { TIFFError(module, "%s: Cannot open", name); return ((TIFF *)0); } return (TIFFFdOpen((int)fd, name, mode)); } tdata_t _TIFFmalloc(tsize_t s) { return ((tdata_t)GlobalAlloc(GMEM_FIXED, s)); } void _TIFFfree(tdata_t p) { GlobalFree(p); return; } tdata_t _TIFFrealloc(tdata_t p, tsize_t s) { void* pvTmp; if ((pvTmp = GlobalReAlloc(p, s, 0)) == NULL) { if ((pvTmp = GlobalAlloc(GMEM_FIXED, s)) != NULL) { CopyMemory(pvTmp, p, GlobalSize(p)); GlobalFree(p); } } return ((tdata_t)pvTmp); } void _TIFFmemset(void* p, int v, tsize_t c) { FillMemory(p, c, (BYTE)v); } void _TIFFmemcpy(void* d, const tdata_t s, tsize_t c) { CopyMemory(d, s, c); } int _TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c) { register const BYTE *pb1 = (const BYTE *) p1; register const BYTE *pb2 = (const BYTE *) p2; register DWORD dwTmp = c; register int iTmp; for (iTmp = 0; dwTmp-- && !iTmp; iTmp = (int)*pb1++ - (int)*pb2++) ; return (iTmp); } static void Win32WarningHandler(const char* module, const char* fmt, va_list ap) { #ifndef TIF_PLATFORM_CONSOLE LPTSTR szTitle; LPTSTR szTmp; LPCTSTR szTitleText = "%s Warning"; LPCTSTR szDefaultModule = "TIFFLIB"; szTmp = (module == NULL) ? (LPTSTR)szDefaultModule : (LPTSTR)module; if ((szTitle = (LPTSTR)LocalAlloc(LMEM_FIXED, (lstrlen(szTmp) + lstrlen(szTitleText) + lstrlen(fmt) + 128)*sizeof(TCHAR))) == NULL) return; wsprintf(szTitle, szTitleText, szTmp); szTmp = szTitle + (lstrlen(szTitle)+2)*sizeof(TCHAR); wvsprintf(szTmp, fmt, ap); MessageBox(GetFocus(), szTmp, szTitle, MB_OK | MB_ICONINFORMATION); LocalFree(szTitle); return; #else if (module != NULL) fprintf(stderr, "%s: ", module); fprintf(stderr, "Warning, "); vfprintf(stderr, fmt, ap); fprintf(stderr, ".\n"); #endif } TIFFErrorHandler _TIFFwarningHandler = Win32WarningHandler; static void Win32ErrorHandler(const char* module, const char* fmt, va_list ap) { #ifndef TIF_PLATFORM_CONSOLE LPTSTR szTitle; LPTSTR szTmp; LPCTSTR szTitleText = "%s Error"; LPCTSTR szDefaultModule = "TIFFLIB"; szTmp = (module == NULL) ? (LPTSTR)szDefaultModule : (LPTSTR)module; if ((szTitle = (LPTSTR)LocalAlloc(LMEM_FIXED, (lstrlen(szTmp) + lstrlen(szTitleText) + lstrlen(fmt) + 128)*sizeof(TCHAR))) == NULL) return; wsprintf(szTitle, szTitleText, szTmp); szTmp = szTitle + (lstrlen(szTitle)+2)*sizeof(TCHAR); wvsprintf(szTmp, fmt, ap); MessageBox(GetFocus(), szTmp, szTitle, MB_OK | MB_ICONEXCLAMATION); LocalFree(szTitle); return; #else if (module != NULL) fprintf(stderr, "%s: ", module); vfprintf(stderr, fmt, ap); fprintf(stderr, ".\n"); #endif } TIFFErrorHandler _TIFFerrorHandler = Win32ErrorHandler; netpbm-8.2/libtiff/tif_write.c0100660000076400000000000004736407020756515015472 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_write.c,v 1.2 1999/11/30 14:21:01 warmerda Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * TIFF Library. * * Scanline-oriented Write Support */ #include "tiffiop.h" #include #include #define STRIPINCR 20 /* expansion factor on strip array */ #define WRITECHECKSTRIPS(tif, module) \ (((tif)->tif_flags&TIFF_BEENWRITING) || TIFFWriteCheck((tif),0,module)) #define WRITECHECKTILES(tif, module) \ (((tif)->tif_flags&TIFF_BEENWRITING) || TIFFWriteCheck((tif),1,module)) #define BUFFERCHECK(tif) \ (((tif)->tif_flags & TIFF_BUFFERSETUP) || \ TIFFWriteBufferSetup((tif), NULL, (tsize_t) -1)) static int TIFFWriteCheck(TIFF*, int, const char*); static int TIFFGrowStrips(TIFF*, int, const char*); static int TIFFAppendToStrip(TIFF*, tstrip_t, tidata_t, tsize_t); static int TIFFSetupStrips(TIFF*); int TIFFWriteScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample) { static const char module[] = "TIFFWriteScanline"; register TIFFDirectory *td; int status, imagegrew = 0; tstrip_t strip; if (!WRITECHECKSTRIPS(tif, module)) return (-1); /* * Handle delayed allocation of data buffer. This * permits it to be sized more intelligently (using * directory information). */ if (!BUFFERCHECK(tif)) return (-1); td = &tif->tif_dir; /* * Extend image length if needed * (but only for PlanarConfig=1). */ if (row >= td->td_imagelength) { /* extend image */ if (td->td_planarconfig == PLANARCONFIG_SEPARATE) { TIFFError(tif->tif_name, "Can not change \"ImageLength\" when using separate planes"); return (-1); } td->td_imagelength = row+1; imagegrew = 1; } /* * Calculate strip and check for crossings. */ if (td->td_planarconfig == PLANARCONFIG_SEPARATE) { if (sample >= td->td_samplesperpixel) { TIFFError(tif->tif_name, "%d: Sample out of range, max %d", sample, td->td_samplesperpixel); return (-1); } strip = sample*td->td_stripsperimage + row/td->td_rowsperstrip; } else strip = row / td->td_rowsperstrip; if (strip != tif->tif_curstrip) { /* * Changing strips -- flush any data present. */ if (!TIFFFlushData(tif)) return (-1); tif->tif_curstrip = strip; /* * Watch out for a growing image. The value of * strips/image will initially be 1 (since it * can't be deduced until the imagelength is known). */ if (strip >= td->td_stripsperimage && imagegrew) td->td_stripsperimage = TIFFhowmany(td->td_imagelength,td->td_rowsperstrip); tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip; if ((tif->tif_flags & TIFF_CODERSETUP) == 0) { if (!(*tif->tif_setupencode)(tif)) return (-1); tif->tif_flags |= TIFF_CODERSETUP; } if (!(*tif->tif_preencode)(tif, sample)) return (-1); tif->tif_flags |= TIFF_POSTENCODE; } /* * Check strip array to make sure there's space. * We don't support dynamically growing files that * have data organized in separate bitplanes because * it's too painful. In that case we require that * the imagelength be set properly before the first * write (so that the strips array will be fully * allocated above). */ if (strip >= td->td_nstrips && !TIFFGrowStrips(tif, 1, module)) return (-1); /* * Ensure the write is either sequential or at the * beginning of a strip (or that we can randomly * access the data -- i.e. no encoding). */ if (row != tif->tif_row) { if (row < tif->tif_row) { /* * Moving backwards within the same strip: * backup to the start and then decode * forward (below). */ tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip; tif->tif_rawcp = tif->tif_rawdata; } /* * Seek forward to the desired row. */ if (!(*tif->tif_seek)(tif, row - tif->tif_row)) return (-1); tif->tif_row = row; } status = (*tif->tif_encoderow)(tif, (tidata_t) buf, tif->tif_scanlinesize, sample); tif->tif_row++; return (status); } /* * Encode the supplied data and write it to the * specified strip. There must be space for the * data; we don't check if strips overlap! * * NB: Image length must be setup before writing. */ tsize_t TIFFWriteEncodedStrip(TIFF* tif, tstrip_t strip, tdata_t data, tsize_t cc) { static const char module[] = "TIFFWriteEncodedStrip"; TIFFDirectory *td = &tif->tif_dir; tsample_t sample; if (!WRITECHECKSTRIPS(tif, module)) return ((tsize_t) -1); /* * Check strip array to make sure there's space. * We don't support dynamically growing files that * have data organized in separate bitplanes because * it's too painful. In that case we require that * the imagelength be set properly before the first * write (so that the strips array will be fully * allocated above). */ if (strip >= td->td_nstrips) { if (td->td_planarconfig == PLANARCONFIG_SEPARATE) { TIFFError(tif->tif_name, "Can not grow image by strips when using separate planes"); return ((tsize_t) -1); } if (!TIFFGrowStrips(tif, 1, module)) return ((tsize_t) -1); td->td_stripsperimage = TIFFhowmany(td->td_imagelength, td->td_rowsperstrip); } /* * Handle delayed allocation of data buffer. This * permits it to be sized according to the directory * info. */ if (!BUFFERCHECK(tif)) return ((tsize_t) -1); tif->tif_curstrip = strip; tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip; if ((tif->tif_flags & TIFF_CODERSETUP) == 0) { if (!(*tif->tif_setupencode)(tif)) return ((tsize_t) -1); tif->tif_flags |= TIFF_CODERSETUP; } #ifdef REWRITE_HACK tif->tif_rawcc = 0; tif->tif_rawcp = tif->tif_rawdata; if( td->td_stripbytecount[strip] > 0 ) { /* if we are writing over existing tiles, zero length. */ td->td_stripbytecount[strip] = 0; /* this forces TIFFAppendToStrip() to do a seek */ tif->tif_curoff = 0; } #endif tif->tif_flags &= ~TIFF_POSTENCODE; sample = (tsample_t)(strip / td->td_stripsperimage); if (!(*tif->tif_preencode)(tif, sample)) return ((tsize_t) -1); if (!(*tif->tif_encodestrip)(tif, (tidata_t) data, cc, sample)) return ((tsize_t) 0); if (!(*tif->tif_postencode)(tif)) return ((tsize_t) -1); if (!isFillOrder(tif, td->td_fillorder) && (tif->tif_flags & TIFF_NOBITREV) == 0) TIFFReverseBits(tif->tif_rawdata, tif->tif_rawcc); if (tif->tif_rawcc > 0 && !TIFFAppendToStrip(tif, strip, tif->tif_rawdata, tif->tif_rawcc)) return ((tsize_t) -1); tif->tif_rawcc = 0; tif->tif_rawcp = tif->tif_rawdata; return (cc); } /* * Write the supplied data to the specified strip. * There must be space for the data; we don't check * if strips overlap! * * NB: Image length must be setup before writing. */ tsize_t TIFFWriteRawStrip(TIFF* tif, tstrip_t strip, tdata_t data, tsize_t cc) { static const char module[] = "TIFFWriteRawStrip"; TIFFDirectory *td = &tif->tif_dir; if (!WRITECHECKSTRIPS(tif, module)) return ((tsize_t) -1); /* * Check strip array to make sure there's space. * We don't support dynamically growing files that * have data organized in separate bitplanes because * it's too painful. In that case we require that * the imagelength be set properly before the first * write (so that the strips array will be fully * allocated above). */ if (strip >= td->td_nstrips) { if (td->td_planarconfig == PLANARCONFIG_SEPARATE) { TIFFError(tif->tif_name, "Can not grow image by strips when using separate planes"); return ((tsize_t) -1); } /* * Watch out for a growing image. The value of * strips/image will initially be 1 (since it * can't be deduced until the imagelength is known). */ if (strip >= td->td_stripsperimage) td->td_stripsperimage = TIFFhowmany(td->td_imagelength,td->td_rowsperstrip); if (!TIFFGrowStrips(tif, 1, module)) return ((tsize_t) -1); } tif->tif_curstrip = strip; tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip; return (TIFFAppendToStrip(tif, strip, (tidata_t) data, cc) ? cc : (tsize_t) -1); } /* * Write and compress a tile of data. The * tile is selected by the (x,y,z,s) coordinates. */ tsize_t TIFFWriteTile(TIFF* tif, tdata_t buf, uint32 x, uint32 y, uint32 z, tsample_t s) { if (!TIFFCheckTile(tif, x, y, z, s)) return (-1); /* * NB: A tile size of -1 is used instead of tif_tilesize knowing * that TIFFWriteEncodedTile will clamp this to the tile size. * This is done because the tile size may not be defined until * after the output buffer is setup in TIFFWriteBufferSetup. */ return (TIFFWriteEncodedTile(tif, TIFFComputeTile(tif, x, y, z, s), buf, (tsize_t) -1)); } /* * Encode the supplied data and write it to the * specified tile. There must be space for the * data. The function clamps individual writes * to a tile to the tile size, but does not (and * can not) check that multiple writes to the same * tile do not write more than tile size data. * * NB: Image length must be setup before writing; this * interface does not support automatically growing * the image on each write (as TIFFWriteScanline does). */ tsize_t TIFFWriteEncodedTile(TIFF* tif, ttile_t tile, tdata_t data, tsize_t cc) { static const char module[] = "TIFFWriteEncodedTile"; TIFFDirectory *td; tsample_t sample; if (!WRITECHECKTILES(tif, module)) return ((tsize_t) -1); td = &tif->tif_dir; if (tile >= td->td_nstrips) { TIFFError(module, "%s: Tile %lu out of range, max %lu", tif->tif_name, (u_long) tile, (u_long) td->td_nstrips); return ((tsize_t) -1); } /* * Handle delayed allocation of data buffer. This * permits it to be sized more intelligently (using * directory information). */ if (!BUFFERCHECK(tif)) return ((tsize_t) -1); tif->tif_curtile = tile; #ifdef REWRITE_HACK tif->tif_rawcc = 0; tif->tif_rawcp = tif->tif_rawdata; if( td->td_stripbytecount[tile] > 0 ) { /* if we are writing over existing tiles, zero length. */ td->td_stripbytecount[tile] = 0; /* this forces TIFFAppendToStrip() to do a seek */ tif->tif_curoff = 0; } #endif /* * Compute tiles per row & per column to compute * current row and column */ tif->tif_row = (tile % TIFFhowmany(td->td_imagelength, td->td_tilelength)) * td->td_tilelength; tif->tif_col = (tile % TIFFhowmany(td->td_imagewidth, td->td_tilewidth)) * td->td_tilewidth; if ((tif->tif_flags & TIFF_CODERSETUP) == 0) { if (!(*tif->tif_setupencode)(tif)) return ((tsize_t) -1); tif->tif_flags |= TIFF_CODERSETUP; } tif->tif_flags &= ~TIFF_POSTENCODE; sample = (tsample_t)(tile/td->td_stripsperimage); if (!(*tif->tif_preencode)(tif, sample)) return ((tsize_t) -1); /* * Clamp write amount to the tile size. This is mostly * done so that callers can pass in some large number * (e.g. -1) and have the tile size used instead. */ if ((uint32) cc > tif->tif_tilesize) cc = tif->tif_tilesize; if (!(*tif->tif_encodetile)(tif, (tidata_t) data, cc, sample)) return ((tsize_t) 0); if (!(*tif->tif_postencode)(tif)) return ((tsize_t) -1); if (!isFillOrder(tif, td->td_fillorder) && (tif->tif_flags & TIFF_NOBITREV) == 0) TIFFReverseBits((u_char *)tif->tif_rawdata, tif->tif_rawcc); if (tif->tif_rawcc > 0 && !TIFFAppendToStrip(tif, tile, tif->tif_rawdata, tif->tif_rawcc)) return ((tsize_t) -1); tif->tif_rawcc = 0; tif->tif_rawcp = tif->tif_rawdata; return (cc); } /* * Write the supplied data to the specified strip. * There must be space for the data; we don't check * if strips overlap! * * NB: Image length must be setup before writing; this * interface does not support automatically growing * the image on each write (as TIFFWriteScanline does). */ tsize_t TIFFWriteRawTile(TIFF* tif, ttile_t tile, tdata_t data, tsize_t cc) { static const char module[] = "TIFFWriteRawTile"; if (!WRITECHECKTILES(tif, module)) return ((tsize_t) -1); if (tile >= tif->tif_dir.td_nstrips) { TIFFError(module, "%s: Tile %lu out of range, max %lu", tif->tif_name, (u_long) tile, (u_long) tif->tif_dir.td_nstrips); return ((tsize_t) -1); } return (TIFFAppendToStrip(tif, tile, (tidata_t) data, cc) ? cc : (tsize_t) -1); } #define isUnspecified(tif, f) \ (TIFFFieldSet(tif,f) && (tif)->tif_dir.td_imagelength == 0) static int TIFFSetupStrips(TIFF* tif) { TIFFDirectory* td = &tif->tif_dir; if (isTiled(tif)) td->td_stripsperimage = isUnspecified(tif, FIELD_TILEDIMENSIONS) ? td->td_samplesperpixel : TIFFNumberOfTiles(tif); else td->td_stripsperimage = isUnspecified(tif, FIELD_ROWSPERSTRIP) ? td->td_samplesperpixel : TIFFNumberOfStrips(tif); td->td_nstrips = td->td_stripsperimage; if (td->td_planarconfig == PLANARCONFIG_SEPARATE) td->td_stripsperimage /= td->td_samplesperpixel; td->td_stripoffset = (uint32 *) _TIFFmalloc(td->td_nstrips * sizeof (uint32)); td->td_stripbytecount = (uint32 *) _TIFFmalloc(td->td_nstrips * sizeof (uint32)); if (td->td_stripoffset == NULL || td->td_stripbytecount == NULL) return (0); /* * Place data at the end-of-file * (by setting offsets to zero). */ _TIFFmemset(td->td_stripoffset, 0, td->td_nstrips*sizeof (uint32)); _TIFFmemset(td->td_stripbytecount, 0, td->td_nstrips*sizeof (uint32)); TIFFSetFieldBit(tif, FIELD_STRIPOFFSETS); TIFFSetFieldBit(tif, FIELD_STRIPBYTECOUNTS); return (1); } #undef isUnspecified /* * Verify file is writable and that the directory * information is setup properly. In doing the latter * we also "freeze" the state of the directory so * that important information is not changed. */ static int TIFFWriteCheck(TIFF* tif, int tiles, const char* module) { if (tif->tif_mode == O_RDONLY) { TIFFError(module, "%s: File not open for writing", tif->tif_name); return (0); } if (tiles ^ isTiled(tif)) { TIFFError(tif->tif_name, tiles ? "Can not write tiles to a stripped image" : "Can not write scanlines to a tiled image"); return (0); } /* * On the first write verify all the required information * has been setup and initialize any data structures that * had to wait until directory information was set. * Note that a lot of our work is assumed to remain valid * because we disallow any of the important parameters * from changing after we start writing (i.e. once * TIFF_BEENWRITING is set, TIFFSetField will only allow * the image's length to be changed). */ if (!TIFFFieldSet(tif, FIELD_IMAGEDIMENSIONS)) { TIFFError(module, "%s: Must set \"ImageWidth\" before writing data", tif->tif_name); return (0); } if (!TIFFFieldSet(tif, FIELD_PLANARCONFIG)) { TIFFError(module, "%s: Must set \"PlanarConfiguration\" before writing data", tif->tif_name); return (0); } if (tif->tif_dir.td_stripoffset == NULL && !TIFFSetupStrips(tif)) { tif->tif_dir.td_nstrips = 0; TIFFError(module, "%s: No space for %s arrays", tif->tif_name, isTiled(tif) ? "tile" : "strip"); return (0); } tif->tif_tilesize = TIFFTileSize(tif); tif->tif_scanlinesize = TIFFScanlineSize(tif); tif->tif_flags |= TIFF_BEENWRITING; return (1); } /* * Setup the raw data buffer used for encoding. */ int TIFFWriteBufferSetup(TIFF* tif, tdata_t bp, tsize_t size) { static const char module[] = "TIFFWriteBufferSetup"; if (tif->tif_rawdata) { if (tif->tif_flags & TIFF_MYBUFFER) { _TIFFfree(tif->tif_rawdata); tif->tif_flags &= ~TIFF_MYBUFFER; } tif->tif_rawdata = NULL; } if (size == (tsize_t) -1) { size = (isTiled(tif) ? tif->tif_tilesize : tif->tif_scanlinesize); /* * Make raw data buffer at least 8K */ if (size < 8*1024) size = 8*1024; bp = NULL; /* NB: force malloc */ } if (bp == NULL) { bp = _TIFFmalloc(size); if (bp == NULL) { TIFFError(module, "%s: No space for output buffer", tif->tif_name); return (0); } tif->tif_flags |= TIFF_MYBUFFER; } else tif->tif_flags &= ~TIFF_MYBUFFER; tif->tif_rawdata = (tidata_t) bp; tif->tif_rawdatasize = size; tif->tif_rawcc = 0; tif->tif_rawcp = tif->tif_rawdata; tif->tif_flags |= TIFF_BUFFERSETUP; return (1); } /* * Grow the strip data structures by delta strips. */ static int TIFFGrowStrips(TIFF* tif, int delta, const char* module) { TIFFDirectory *td = &tif->tif_dir; assert(td->td_planarconfig == PLANARCONFIG_CONTIG); td->td_stripoffset = (uint32*)_TIFFrealloc(td->td_stripoffset, (td->td_nstrips + delta) * sizeof (uint32)); td->td_stripbytecount = (uint32*)_TIFFrealloc(td->td_stripbytecount, (td->td_nstrips + delta) * sizeof (uint32)); if (td->td_stripoffset == NULL || td->td_stripbytecount == NULL) { td->td_nstrips = 0; TIFFError(module, "%s: No space to expand strip arrays", tif->tif_name); return (0); } _TIFFmemset(td->td_stripoffset+td->td_nstrips, 0, delta*sizeof (uint32)); _TIFFmemset(td->td_stripbytecount+td->td_nstrips, 0, delta*sizeof (uint32)); td->td_nstrips += delta; return (1); } /* * Append the data to the specified strip. * * NB: We don't check that there's space in the * file (i.e. that strips do not overlap). */ static int TIFFAppendToStrip(TIFF* tif, tstrip_t strip, tidata_t data, tsize_t cc) { TIFFDirectory *td = &tif->tif_dir; static const char module[] = "TIFFAppendToStrip"; if (td->td_stripoffset[strip] == 0 || tif->tif_curoff == 0) { /* * No current offset, set the current strip. */ if (td->td_stripoffset[strip] != 0) { if (!SeekOK(tif, td->td_stripoffset[strip])) { TIFFError(module, "%s: Seek error at scanline %lu", tif->tif_name, (u_long) tif->tif_row); return (0); } } else td->td_stripoffset[strip] = TIFFSeekFile(tif, (toff_t) 0, SEEK_END); tif->tif_curoff = td->td_stripoffset[strip]; } if (!WriteOK(tif, data, cc)) { TIFFError(module, "%s: Write error at scanline %lu", tif->tif_name, (u_long) tif->tif_row); return (0); } tif->tif_curoff += cc; td->td_stripbytecount[strip] += cc; return (1); } /* * Internal version of TIFFFlushData that can be * called by ``encodestrip routines'' w/o concern * for infinite recursion. */ int TIFFFlushData1(TIFF* tif) { if (tif->tif_rawcc > 0) { if (!isFillOrder(tif, tif->tif_dir.td_fillorder) && (tif->tif_flags & TIFF_NOBITREV) == 0) TIFFReverseBits((u_char *)tif->tif_rawdata, tif->tif_rawcc); if (!TIFFAppendToStrip(tif, isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip, tif->tif_rawdata, tif->tif_rawcc)) return (0); tif->tif_rawcc = 0; tif->tif_rawcp = tif->tif_rawdata; } return (1); } /* * Set the current write offset. This should only be * used to set the offset to a known previous location * (very carefully), or to 0 so that the next write gets * appended to the end of the file. */ void TIFFSetWriteOffset(TIFF* tif, toff_t off) { tif->tif_curoff = off; } netpbm-8.2/libtiff/tif_zip.c0100660000076400000000000002327407023237712015130 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tif_zip.c,v 1.2 1999/12/07 17:11:38 mwelles Exp $ */ /* * Copyright (c) 1995-1997 Sam Leffler * Copyright (c) 1995-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * 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. */ #include "tiffiop.h" #ifdef ZIP_SUPPORT /* * TIFF Library. * * ZIP (aka Deflate) Compression Support * * This file is simply an interface to the zlib library written by * Jean-loup Gailly and Mark Adler. You must use version 1.0 or later * of the library: this code assumes the 1.0 API and also depends on * the ability to write the zlib header multiple times (one per strip) * which was not possible with versions prior to 0.95. Note also that * older versions of this codec avoided this bug by supressing the header * entirely. This means that files written with the old library cannot * be read; they should be converted to a different compression scheme * and then reconverted. * * The data format used by the zlib library is described in the files * zlib-3.1.doc, deflate-1.1.doc and gzip-4.1.doc, available in the * directory ftp://ftp.uu.net/pub/archiving/zip/doc. The library was * last found at ftp://ftp.uu.net/pub/archiving/zip/zlib/zlib-0.99.tar.gz. */ #include "tif_predict.h" #include "zlib.h" #include #include /* * Sigh, ZLIB_VERSION is defined as a string so there's no * way to do a proper check here. Instead we guess based * on the presence of #defines that were added between the * 0.95 and 1.0 distributions. */ #if !defined(Z_NO_COMPRESSION) || !defined(Z_DEFLATED) #error "Antiquated ZLIB software; you must use version 1.0 or later" #endif /* * State block for each open TIFF * file using ZIP compression/decompression. */ typedef struct { TIFFPredictorState predict; z_stream stream; int zipquality; /* compression level */ int state; /* state flags */ #define ZSTATE_INIT 0x1 /* zlib setup successfully */ TIFFVGetMethod vgetparent; /* super-class method */ TIFFVSetMethod vsetparent; /* super-class method */ } ZIPState; #define ZState(tif) ((ZIPState*) (tif)->tif_data) #define DecoderState(tif) ZState(tif) #define EncoderState(tif) ZState(tif) static int ZIPEncode(TIFF*, tidata_t, tsize_t, tsample_t); static int ZIPDecode(TIFF*, tidata_t, tsize_t, tsample_t); static int ZIPSetupDecode(TIFF* tif) { ZIPState* sp = DecoderState(tif); static const char module[] = "ZIPSetupDecode"; assert(sp != NULL); if (inflateInit(&sp->stream) != Z_OK) { TIFFError(module, "%s: %s", tif->tif_name, sp->stream.msg); return (0); } else { sp->state |= ZSTATE_INIT; return (1); } } /* * Setup state for decoding a strip. */ static int ZIPPreDecode(TIFF* tif, tsample_t s) { ZIPState* sp = DecoderState(tif); (void) s; assert(sp != NULL); sp->stream.next_in = tif->tif_rawdata; sp->stream.avail_in = tif->tif_rawcc; return (inflateReset(&sp->stream) == Z_OK); } static int ZIPDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s) { ZIPState* sp = DecoderState(tif); static const char module[] = "ZIPDecode"; (void) s; assert(sp != NULL); sp->stream.next_out = op; sp->stream.avail_out = occ; do { int state = inflate(&sp->stream, Z_PARTIAL_FLUSH); if (state == Z_STREAM_END) break; if (state == Z_DATA_ERROR) { TIFFError(module, "%s: Decoding error at scanline %d, %s", tif->tif_name, tif->tif_row, sp->stream.msg); if (inflateSync(&sp->stream) != Z_OK) return (0); continue; } if (state != Z_OK) { TIFFError(module, "%s: zlib error: %s", tif->tif_name, sp->stream.msg); return (0); } } while (sp->stream.avail_out > 0); if (sp->stream.avail_out != 0) { TIFFError(module, "%s: Not enough data at scanline %d (short %d bytes)", tif->tif_name, tif->tif_row, sp->stream.avail_out); return (0); } return (1); } static int ZIPSetupEncode(TIFF* tif) { ZIPState* sp = EncoderState(tif); static const char module[] = "ZIPSetupEncode"; assert(sp != NULL); if (deflateInit(&sp->stream, sp->zipquality) != Z_OK) { TIFFError(module, "%s: %s", tif->tif_name, sp->stream.msg); return (0); } else { sp->state |= ZSTATE_INIT; return (1); } } /* * Reset encoding state at the start of a strip. */ static int ZIPPreEncode(TIFF* tif, tsample_t s) { ZIPState *sp = EncoderState(tif); (void) s; assert(sp != NULL); sp->stream.next_out = tif->tif_rawdata; sp->stream.avail_out = tif->tif_rawdatasize; return (deflateReset(&sp->stream) == Z_OK); } /* * Encode a chunk of pixels. */ static int ZIPEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s) { ZIPState *sp = EncoderState(tif); static const char module[] = "ZIPEncode"; (void) s; sp->stream.next_in = bp; sp->stream.avail_in = cc; do { if (deflate(&sp->stream, Z_NO_FLUSH) != Z_OK) { TIFFError(module, "%s: Encoder error: %s", tif->tif_name, sp->stream.msg); return (0); } if (sp->stream.avail_out == 0) { tif->tif_rawcc = tif->tif_rawdatasize; TIFFFlushData1(tif); sp->stream.next_out = tif->tif_rawdata; sp->stream.avail_out = tif->tif_rawdatasize; } } while (sp->stream.avail_in > 0); return (1); } /* * Finish off an encoded strip by flushing the last * string and tacking on an End Of Information code. */ static int ZIPPostEncode(TIFF* tif) { ZIPState *sp = EncoderState(tif); static const char module[] = "ZIPPostEncode"; int state; sp->stream.avail_in = 0; do { state = deflate(&sp->stream, Z_FINISH); switch (state) { case Z_STREAM_END: case Z_OK: if (sp->stream.avail_out != tif->tif_rawdatasize) { tif->tif_rawcc = tif->tif_rawdatasize - sp->stream.avail_out; TIFFFlushData1(tif); sp->stream.next_out = tif->tif_rawdata; sp->stream.avail_out = tif->tif_rawdatasize; } break; default: TIFFError(module, "%s: zlib error: %s", tif->tif_name, sp->stream.msg); return (0); } } while (state != Z_STREAM_END); return (1); } static void ZIPCleanup(TIFF* tif) { ZIPState* sp = ZState(tif); if (sp) { if (sp->state&ZSTATE_INIT) { /* NB: avoid problems in the library */ if (tif->tif_mode == O_RDONLY) inflateEnd(&sp->stream); else deflateEnd(&sp->stream); } _TIFFfree(sp); tif->tif_data = NULL; } } static int ZIPVSetField(TIFF* tif, ttag_t tag, va_list ap) { ZIPState* sp = ZState(tif); static const char module[] = "ZIPVSetField"; switch (tag) { case TIFFTAG_ZIPQUALITY: sp->zipquality = va_arg(ap, int); if (tif->tif_mode != O_RDONLY && (sp->state&ZSTATE_INIT)) { if (deflateParams(&sp->stream, sp->zipquality, Z_DEFAULT_STRATEGY) != Z_OK) { TIFFError(module, "%s: zlib error: %s", tif->tif_name, sp->stream.msg); return (0); } } return (1); default: return (*sp->vsetparent)(tif, tag, ap); } /*NOTREACHED*/ } static int ZIPVGetField(TIFF* tif, ttag_t tag, va_list ap) { ZIPState* sp = ZState(tif); switch (tag) { case TIFFTAG_ZIPQUALITY: *va_arg(ap, int*) = sp->zipquality; break; default: return (*sp->vgetparent)(tif, tag, ap); } return (1); } static const TIFFFieldInfo zipFieldInfo[] = { { TIFFTAG_ZIPQUALITY, 0, 0, TIFF_ANY, FIELD_PSEUDO, TRUE, FALSE, "" }, }; #define N(a) (sizeof (a) / sizeof (a[0])) int TIFFInitZIP(TIFF* tif, int scheme) { ZIPState* sp; assert( (scheme == COMPRESSION_DEFLATE) || (scheme == COMPRESSION_ADOBE_DEFLATE)); /* * Allocate state block so tag methods have storage to record values. */ tif->tif_data = (tidata_t) _TIFFmalloc(sizeof (ZIPState)); if (tif->tif_data == NULL) goto bad; sp = ZState(tif); sp->stream.zalloc = NULL; sp->stream.zfree = NULL; sp->stream.opaque = NULL; sp->stream.data_type = Z_BINARY; /* * Merge codec-specific tag information and * override parent get/set field methods. */ _TIFFMergeFieldInfo(tif, zipFieldInfo, N(zipFieldInfo)); sp->vgetparent = tif->tif_vgetfield; tif->tif_vgetfield = ZIPVGetField; /* hook for codec tags */ sp->vsetparent = tif->tif_vsetfield; tif->tif_vsetfield = ZIPVSetField; /* hook for codec tags */ /* Default values for codec-specific fields */ sp->zipquality = Z_DEFAULT_COMPRESSION; /* default comp. level */ sp->state = 0; /* * Install codec methods. */ tif->tif_setupdecode = ZIPSetupDecode; tif->tif_predecode = ZIPPreDecode; tif->tif_decoderow = ZIPDecode; tif->tif_decodestrip = ZIPDecode; tif->tif_decodetile = ZIPDecode; tif->tif_setupencode = ZIPSetupEncode; tif->tif_preencode = ZIPPreEncode; tif->tif_postencode = ZIPPostEncode; tif->tif_encoderow = ZIPEncode; tif->tif_encodestrip = ZIPEncode; tif->tif_encodetile = ZIPEncode; tif->tif_cleanup = ZIPCleanup; /* * Setup predictor setup. */ (void) TIFFPredictorInit(tif); return (1); bad: TIFFError("TIFFInitZIP", "No space for ZIP state block"); return (0); } #endif /* ZIP_SUPORT */ netpbm-8.2/libtiff/tiff.h0100660000076400000000000005471407027731307014427 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tiff.h,v 1.4 1999/12/21 17:03:03 mwelles Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #ifndef _TIFF_ #define _TIFF_ /* * Tag Image File Format (TIFF) * * Based on Rev 6.0 from: * Developer's Desk * Aldus Corporation * 411 First Ave. South * Suite 200 * Seattle, WA 98104 * 206-622-5500 */ #define TIFF_VERSION 42 #define TIFF_BIGENDIAN 0x4d4d #define TIFF_LITTLEENDIAN 0x4949 #ifndef _TIFF_DATA_TYPEDEFS_ #define _TIFF_DATA_TYPEDEFS_ /* * Intrinsic data types required by the file format: * * 8-bit quantities int8/uint8 * 16-bit quantities int16/uint16 * 32-bit quantities int32/uint32 * strings unsigned char* */ #ifdef __STDC__ typedef signed char int8; /* NB: non-ANSI compilers may not grok */ #else typedef char int8; #endif typedef unsigned char uint8; typedef short int16; typedef unsigned short uint16; /* sizeof (uint16) must == 2 */ #if defined(__alpha) || (defined(_MIPS_SZLONG) && _MIPS_SZLONG == 64) typedef int int32; typedef unsigned int uint32; /* sizeof (uint32) must == 4 */ #else typedef long int32; typedef unsigned long uint32; /* sizeof (uint32) must == 4 */ #endif #endif /* _TIFF_DATA_TYPEDEFS_ */ /* For TIFFReassignTagToIgnore */ enum TIFFIgnoreSense /* IGNORE tag table */ { TIS_STORE, TIS_EXTRACT, TIS_EMPTY }; typedef struct { uint16 tiff_magic; /* magic number (defines byte order) */ uint16 tiff_version; /* TIFF version number */ uint32 tiff_diroff; /* byte offset to first directory */ } TIFFHeader; /* * TIFF Image File Directories are comprised of * a table of field descriptors of the form shown * below. The table is sorted in ascending order * by tag. The values associated with each entry * are disjoint and may appear anywhere in the file * (so long as they are placed on a word boundary). * * If the value is 4 bytes or less, then it is placed * in the offset field to save space. If the value * is less than 4 bytes, it is left-justified in the * offset field. */ typedef struct { uint16 tdir_tag; /* see below */ uint16 tdir_type; /* data type; see below */ uint32 tdir_count; /* number of items; length in spec */ uint32 tdir_offset; /* byte offset to field data */ } TIFFDirEntry; /* * NB: In the comments below, * - items marked with a + are obsoleted by revision 5.0, * - items marked with a ! are introduced in revision 6.0. * - items marked with a % are introduced post revision 6.0. * - items marked with a $ are obsoleted by revision 6.0. */ /* * Tag data type information. * * Note: RATIONALs are the ratio of two 32-bit integer values. */ typedef enum { TIFF_NOTYPE = 0, /* placeholder */ TIFF_BYTE = 1, /* 8-bit unsigned integer */ TIFF_ASCII = 2, /* 8-bit bytes w/ last byte null */ TIFF_SHORT = 3, /* 16-bit unsigned integer */ TIFF_LONG = 4, /* 32-bit unsigned integer */ TIFF_RATIONAL = 5, /* 64-bit unsigned fraction */ TIFF_SBYTE = 6, /* !8-bit signed integer */ TIFF_UNDEFINED = 7, /* !8-bit untyped data */ TIFF_SSHORT = 8, /* !16-bit signed integer */ TIFF_SLONG = 9, /* !32-bit signed integer */ TIFF_SRATIONAL = 10, /* !64-bit signed fraction */ TIFF_FLOAT = 11, /* !32-bit IEEE floating point */ TIFF_DOUBLE = 12 /* !64-bit IEEE floating point */ } TIFFDataType; /* * TIFF Tag Definitions. */ #define TIFFTAG_SUBFILETYPE 254 /* subfile data descriptor */ #define FILETYPE_REDUCEDIMAGE 0x1 /* reduced resolution version */ #define FILETYPE_PAGE 0x2 /* one page of many */ #define FILETYPE_MASK 0x4 /* transparency mask */ #define TIFFTAG_OSUBFILETYPE 255 /* +kind of data in subfile */ #define OFILETYPE_IMAGE 1 /* full resolution image data */ #define OFILETYPE_REDUCEDIMAGE 2 /* reduced size image data */ #define OFILETYPE_PAGE 3 /* one page of many */ #define TIFFTAG_IMAGEWIDTH 256 /* image width in pixels */ #define TIFFTAG_IMAGELENGTH 257 /* image height in pixels */ #define TIFFTAG_BITSPERSAMPLE 258 /* bits per channel (sample) */ #define TIFFTAG_COMPRESSION 259 /* data compression technique */ #define COMPRESSION_NONE 1 /* dump mode */ #define COMPRESSION_CCITTRLE 2 /* CCITT modified Huffman RLE */ #define COMPRESSION_CCITTFAX3 3 /* CCITT Group 3 fax encoding */ #define COMPRESSION_CCITTFAX4 4 /* CCITT Group 4 fax encoding */ #define COMPRESSION_LZW 5 /* Lempel-Ziv & Welch */ #define COMPRESSION_OJPEG 6 /* !6.0 JPEG */ #define COMPRESSION_JPEG 7 /* %JPEG DCT compression */ #define COMPRESSION_NEXT 32766 /* NeXT 2-bit RLE */ #define COMPRESSION_CCITTRLEW 32771 /* #1 w/ word alignment */ #define COMPRESSION_PACKBITS 32773 /* Macintosh RLE */ #define COMPRESSION_THUNDERSCAN 32809 /* ThunderScan RLE */ /* codes 32895-32898 are reserved for ANSI IT8 TIFF/IT */ #define COMPRESSION_DCS 32947 /* Kodak DCS encoding */ #define COMPRESSION_JBIG 34661 /* ISO JBIG */ #define COMPRESSION_SGILOG 34676 /* SGI Log Luminance RLE */ #define COMPRESSION_SGILOG24 34677 /* SGI Log 24-bit packed */ #define TIFFTAG_PHOTOMETRIC 262 /* photometric interpretation */ #define PHOTOMETRIC_MINISWHITE 0 /* min value is white */ #define PHOTOMETRIC_MINISBLACK 1 /* min value is black */ #define PHOTOMETRIC_RGB 2 /* RGB color model */ #define PHOTOMETRIC_PALETTE 3 /* color map indexed */ #define PHOTOMETRIC_MASK 4 /* $holdout mask */ #define PHOTOMETRIC_SEPARATED 5 /* !color separations */ #define PHOTOMETRIC_YCBCR 6 /* !CCIR 601 */ #define PHOTOMETRIC_CIELAB 8 /* !1976 CIE L*a*b* */ #define PHOTOMETRIC_LOGL 32844 /* CIE Log2(L) */ #define PHOTOMETRIC_LOGLUV 32845 /* CIE Log2(L) (u',v') */ #define TIFFTAG_THRESHHOLDING 263 /* +thresholding used on data */ #define THRESHHOLD_BILEVEL 1 /* b&w art scan */ #define THRESHHOLD_HALFTONE 2 /* or dithered scan */ #define THRESHHOLD_ERRORDIFFUSE 3 /* usually floyd-steinberg */ #define TIFFTAG_CELLWIDTH 264 /* +dithering matrix width */ #define TIFFTAG_CELLLENGTH 265 /* +dithering matrix height */ #define TIFFTAG_FILLORDER 266 /* data order within a byte */ #define FILLORDER_MSB2LSB 1 /* most significant -> least */ #define FILLORDER_LSB2MSB 2 /* least significant -> most */ #define TIFFTAG_DOCUMENTNAME 269 /* name of doc. image is from */ #define TIFFTAG_IMAGEDESCRIPTION 270 /* info about image */ #define TIFFTAG_MAKE 271 /* scanner manufacturer name */ #define TIFFTAG_MODEL 272 /* scanner model name/number */ #define TIFFTAG_STRIPOFFSETS 273 /* offsets to data strips */ #define TIFFTAG_ORIENTATION 274 /* +image orientation */ #define ORIENTATION_TOPLEFT 1 /* row 0 top, col 0 lhs */ #define ORIENTATION_TOPRIGHT 2 /* row 0 top, col 0 rhs */ #define ORIENTATION_BOTRIGHT 3 /* row 0 bottom, col 0 rhs */ #define ORIENTATION_BOTLEFT 4 /* row 0 bottom, col 0 lhs */ #define ORIENTATION_LEFTTOP 5 /* row 0 lhs, col 0 top */ #define ORIENTATION_RIGHTTOP 6 /* row 0 rhs, col 0 top */ #define ORIENTATION_RIGHTBOT 7 /* row 0 rhs, col 0 bottom */ #define ORIENTATION_LEFTBOT 8 /* row 0 lhs, col 0 bottom */ #define TIFFTAG_SAMPLESPERPIXEL 277 /* samples per pixel */ #define TIFFTAG_ROWSPERSTRIP 278 /* rows per strip of data */ #define TIFFTAG_STRIPBYTECOUNTS 279 /* bytes counts for strips */ #define TIFFTAG_MINSAMPLEVALUE 280 /* +minimum sample value */ #define TIFFTAG_MAXSAMPLEVALUE 281 /* +maximum sample value */ #define TIFFTAG_XRESOLUTION 282 /* pixels/resolution in x */ #define TIFFTAG_YRESOLUTION 283 /* pixels/resolution in y */ #define TIFFTAG_PLANARCONFIG 284 /* storage organization */ #define PLANARCONFIG_CONTIG 1 /* single image plane */ #define PLANARCONFIG_SEPARATE 2 /* separate planes of data */ #define TIFFTAG_PAGENAME 285 /* page name image is from */ #define TIFFTAG_XPOSITION 286 /* x page offset of image lhs */ #define TIFFTAG_YPOSITION 287 /* y page offset of image lhs */ #define TIFFTAG_FREEOFFSETS 288 /* +byte offset to free block */ #define TIFFTAG_FREEBYTECOUNTS 289 /* +sizes of free blocks */ #define TIFFTAG_GRAYRESPONSEUNIT 290 /* $gray scale curve accuracy */ #define GRAYRESPONSEUNIT_10S 1 /* tenths of a unit */ #define GRAYRESPONSEUNIT_100S 2 /* hundredths of a unit */ #define GRAYRESPONSEUNIT_1000S 3 /* thousandths of a unit */ #define GRAYRESPONSEUNIT_10000S 4 /* ten-thousandths of a unit */ #define GRAYRESPONSEUNIT_100000S 5 /* hundred-thousandths */ #define TIFFTAG_GRAYRESPONSECURVE 291 /* $gray scale response curve */ #define TIFFTAG_GROUP3OPTIONS 292 /* 32 flag bits */ #define GROUP3OPT_2DENCODING 0x1 /* 2-dimensional coding */ #define GROUP3OPT_UNCOMPRESSED 0x2 /* data not compressed */ #define GROUP3OPT_FILLBITS 0x4 /* fill to byte boundary */ #define TIFFTAG_GROUP4OPTIONS 293 /* 32 flag bits */ #define GROUP4OPT_UNCOMPRESSED 0x2 /* data not compressed */ #define TIFFTAG_RESOLUTIONUNIT 296 /* units of resolutions */ #define RESUNIT_NONE 1 /* no meaningful units */ #define RESUNIT_INCH 2 /* english */ #define RESUNIT_CENTIMETER 3 /* metric */ #define TIFFTAG_PAGENUMBER 297 /* page numbers of multi-page */ #define TIFFTAG_COLORRESPONSEUNIT 300 /* $color curve accuracy */ #define COLORRESPONSEUNIT_10S 1 /* tenths of a unit */ #define COLORRESPONSEUNIT_100S 2 /* hundredths of a unit */ #define COLORRESPONSEUNIT_1000S 3 /* thousandths of a unit */ #define COLORRESPONSEUNIT_10000S 4 /* ten-thousandths of a unit */ #define COLORRESPONSEUNIT_100000S 5 /* hundred-thousandths */ #define TIFFTAG_TRANSFERFUNCTION 301 /* !colorimetry info */ #define TIFFTAG_SOFTWARE 305 /* name & release */ #define TIFFTAG_DATETIME 306 /* creation date and time */ #define TIFFTAG_ARTIST 315 /* creator of image */ #define TIFFTAG_HOSTCOMPUTER 316 /* machine where created */ #define TIFFTAG_PREDICTOR 317 /* prediction scheme w/ LZW */ #define TIFFTAG_WHITEPOINT 318 /* image white point */ #define TIFFTAG_PRIMARYCHROMATICITIES 319 /* !primary chromaticities */ #define TIFFTAG_COLORMAP 320 /* RGB map for pallette image */ #define TIFFTAG_HALFTONEHINTS 321 /* !highlight+shadow info */ #define TIFFTAG_TILEWIDTH 322 /* !rows/data tile */ #define TIFFTAG_TILELENGTH 323 /* !cols/data tile */ #define TIFFTAG_TILEOFFSETS 324 /* !offsets to data tiles */ #define TIFFTAG_TILEBYTECOUNTS 325 /* !byte counts for tiles */ #define TIFFTAG_BADFAXLINES 326 /* lines w/ wrong pixel count */ #define TIFFTAG_CLEANFAXDATA 327 /* regenerated line info */ #define CLEANFAXDATA_CLEAN 0 /* no errors detected */ #define CLEANFAXDATA_REGENERATED 1 /* receiver regenerated lines */ #define CLEANFAXDATA_UNCLEAN 2 /* uncorrected errors exist */ #define TIFFTAG_CONSECUTIVEBADFAXLINES 328 /* max consecutive bad lines */ #define TIFFTAG_SUBIFD 330 /* subimage descriptors */ #define TIFFTAG_INKSET 332 /* !inks in separated image */ #define INKSET_CMYK 1 /* !cyan-magenta-yellow-black */ #define TIFFTAG_INKNAMES 333 /* !ascii names of inks */ #define TIFFTAG_NUMBEROFINKS 334 /* !number of inks */ #define TIFFTAG_DOTRANGE 336 /* !0% and 100% dot codes */ #define TIFFTAG_TARGETPRINTER 337 /* !separation target */ #define TIFFTAG_EXTRASAMPLES 338 /* !info about extra samples */ #define EXTRASAMPLE_UNSPECIFIED 0 /* !unspecified data */ #define EXTRASAMPLE_ASSOCALPHA 1 /* !associated alpha data */ #define EXTRASAMPLE_UNASSALPHA 2 /* !unassociated alpha data */ #define TIFFTAG_SAMPLEFORMAT 339 /* !data sample format */ #define SAMPLEFORMAT_UINT 1 /* !unsigned integer data */ #define SAMPLEFORMAT_INT 2 /* !signed integer data */ #define SAMPLEFORMAT_IEEEFP 3 /* !IEEE floating point data */ #define SAMPLEFORMAT_VOID 4 /* !untyped data */ #define TIFFTAG_SMINSAMPLEVALUE 340 /* !variable MinSampleValue */ #define TIFFTAG_SMAXSAMPLEVALUE 341 /* !variable MaxSampleValue */ #define TIFFTAG_JPEGTABLES 347 /* %JPEG table stream */ /* * Tags 512-521 are obsoleted by Technical Note #2 * which specifies a revised JPEG-in-TIFF scheme. */ #define TIFFTAG_JPEGPROC 512 /* !JPEG processing algorithm */ #define JPEGPROC_BASELINE 1 /* !baseline sequential */ #define JPEGPROC_LOSSLESS 14 /* !Huffman coded lossless */ #define TIFFTAG_JPEGIFOFFSET 513 /* !pointer to SOI marker */ #define TIFFTAG_JPEGIFBYTECOUNT 514 /* !JFIF stream length */ #define TIFFTAG_JPEGRESTARTINTERVAL 515 /* !restart interval length */ #define TIFFTAG_JPEGLOSSLESSPREDICTORS 517 /* !lossless proc predictor */ #define TIFFTAG_JPEGPOINTTRANSFORM 518 /* !lossless point transform */ #define TIFFTAG_JPEGQTABLES 519 /* !Q matrice offsets */ #define TIFFTAG_JPEGDCTABLES 520 /* !DCT table offsets */ #define TIFFTAG_JPEGACTABLES 521 /* !AC coefficient offsets */ #define TIFFTAG_YCBCRCOEFFICIENTS 529 /* !RGB -> YCbCr transform */ #define TIFFTAG_YCBCRSUBSAMPLING 530 /* !YCbCr subsampling factors */ #define TIFFTAG_YCBCRPOSITIONING 531 /* !subsample positioning */ #define YCBCRPOSITION_CENTERED 1 /* !as in PostScript Level 2 */ #define YCBCRPOSITION_COSITED 2 /* !as in CCIR 601-1 */ #define TIFFTAG_REFERENCEBLACKWHITE 532 /* !colorimetry info */ /* tags 32952-32956 are private tags registered to Island Graphics */ #define TIFFTAG_REFPTS 32953 /* image reference points */ #define TIFFTAG_REGIONTACKPOINT 32954 /* region-xform tack point */ #define TIFFTAG_REGIONWARPCORNERS 32955 /* warp quadrilateral */ #define TIFFTAG_REGIONAFFINE 32956 /* affine transformation mat */ /* tags 32995-32999 are private tags registered to SGI */ #define TIFFTAG_MATTEING 32995 /* $use ExtraSamples */ #define TIFFTAG_DATATYPE 32996 /* $use SampleFormat */ #define TIFFTAG_IMAGEDEPTH 32997 /* z depth of image */ #define TIFFTAG_TILEDEPTH 32998 /* z depth/data tile */ /* tags 33300-33309 are private tags registered to Pixar */ /* * TIFFTAG_PIXAR_IMAGEFULLWIDTH and TIFFTAG_PIXAR_IMAGEFULLLENGTH * are set when an image has been cropped out of a larger image. * They reflect the size of the original uncropped image. * The TIFFTAG_XPOSITION and TIFFTAG_YPOSITION can be used * to determine the position of the smaller image in the larger one. */ #define TIFFTAG_PIXAR_IMAGEFULLWIDTH 33300 /* full image size in x */ #define TIFFTAG_PIXAR_IMAGEFULLLENGTH 33301 /* full image size in y */ /* Tags 33302-33306 are used to identify special image modes and data * used by Pixar's texture formats. */ #define TIFFTAG_PIXAR_TEXTUREFORMAT 33302 /* texture map format */ #define TIFFTAG_PIXAR_WRAPMODES 33303 /* s & t wrap modes */ #define TIFFTAG_PIXAR_FOVCOT 33304 /* cotan(fov) for env. maps */ #define TIFFTAG_PIXAR_MATRIX_WORLDTOSCREEN 33305 #define TIFFTAG_PIXAR_MATRIX_WORLDTOCAMERA 33306 /* tag 33405 is a private tag registered to Eastman Kodak */ #define TIFFTAG_WRITERSERIALNUMBER 33405 /* device serial number */ /* tag 33432 is listed in the 6.0 spec w/ unknown ownership */ #define TIFFTAG_COPYRIGHT 33432 /* copyright string */ /* IPTC TAG from RichTIFF specifications */ #define TIFFTAG_RICHTIFFIPTC 33723 /* 34016-34029 are reserved for ANSI IT8 TIFF/IT */ #define TIFFTAG_STONITS 37439 /* Sample value to Nits */ /* tag 34929 is a private tag registered to FedEx */ #define TIFFTAG_FEDEX_EDR 34929 /* unknown use */ /* tag 65535 is an undefined tag used by Eastman Kodak */ #define TIFFTAG_DCSHUESHIFTVALUES 65535 /* hue shift correction data */ /* * The following are ``pseudo tags'' that can be * used to control codec-specific functionality. * These tags are not written to file. Note that * these values start at 0xffff+1 so that they'll * never collide with Aldus-assigned tags. * * If you want your private pseudo tags ``registered'' * (i.e. added to this file), send mail to sam@sgi.com * with the appropriate C definitions to add. */ #define TIFFTAG_FAXMODE 65536 /* Group 3/4 format control */ #define FAXMODE_CLASSIC 0x0000 /* default, include RTC */ #define FAXMODE_NORTC 0x0001 /* no RTC at end of data */ #define FAXMODE_NOEOL 0x0002 /* no EOL code at end of row */ #define FAXMODE_BYTEALIGN 0x0004 /* byte align row */ #define FAXMODE_WORDALIGN 0x0008 /* word align row */ #define FAXMODE_CLASSF FAXMODE_NORTC /* TIFF Class F */ #define TIFFTAG_JPEGQUALITY 65537 /* Compression quality level */ /* Note: quality level is on the IJG 0-100 scale. Default value is 75 */ #define TIFFTAG_JPEGCOLORMODE 65538 /* Auto RGB<=>YCbCr convert? */ #define JPEGCOLORMODE_RAW 0x0000 /* no conversion (default) */ #define JPEGCOLORMODE_RGB 0x0001 /* do auto conversion */ #define TIFFTAG_JPEGTABLESMODE 65539 /* What to put in JPEGTables */ #define JPEGTABLESMODE_QUANT 0x0001 /* include quantization tbls */ #define JPEGTABLESMODE_HUFF 0x0002 /* include Huffman tbls */ /* Note: default is JPEGTABLESMODE_QUANT | JPEGTABLESMODE_HUFF */ #define TIFFTAG_FAXFILLFUNC 65540 /* G3/G4 fill function */ #define TIFFTAG_PIXARLOGDATAFMT 65549 /* PixarLogCodec I/O data sz */ #define PIXARLOGDATAFMT_8BIT 0 /* regular u_char samples */ #define PIXARLOGDATAFMT_8BITABGR 1 /* ABGR-order u_chars */ #define PIXARLOGDATAFMT_11BITLOG 2 /* 11-bit log-encoded (raw) */ #define PIXARLOGDATAFMT_12BITPICIO 3 /* as per PICIO (1.0==2048) */ #define PIXARLOGDATAFMT_16BIT 4 /* signed short samples */ #define PIXARLOGDATAFMT_FLOAT 5 /* IEEE float samples */ /* 65550-65556 are allocated to Oceana Matrix */ #define TIFFTAG_DCSIMAGERTYPE 65550 /* imager model & filter */ #define DCSIMAGERMODEL_M3 0 /* M3 chip (1280 x 1024) */ #define DCSIMAGERMODEL_M5 1 /* M5 chip (1536 x 1024) */ #define DCSIMAGERMODEL_M6 2 /* M6 chip (3072 x 2048) */ #define DCSIMAGERFILTER_IR 0 /* infrared filter */ #define DCSIMAGERFILTER_MONO 1 /* monochrome filter */ #define DCSIMAGERFILTER_CFA 2 /* color filter array */ #define DCSIMAGERFILTER_OTHER 3 /* other filter */ #define TIFFTAG_DCSINTERPMODE 65551 /* interpolation mode */ #define DCSINTERPMODE_NORMAL 0x0 /* whole image, default */ #define DCSINTERPMODE_PREVIEW 0x1 /* preview of image (384x256) */ #define TIFFTAG_DCSBALANCEARRAY 65552 /* color balance values */ #define TIFFTAG_DCSCORRECTMATRIX 65553 /* color correction values */ #define TIFFTAG_DCSGAMMA 65554 /* gamma value */ #define TIFFTAG_DCSTOESHOULDERPTS 65555 /* toe & shoulder points */ #define TIFFTAG_DCSCALIBRATIONFD 65556 /* calibration file desc */ /* Note: quality level is on the ZLIB 1-9 scale. Default value is -1 */ #define TIFFTAG_ZIPQUALITY 65557 /* compression quality level */ #define TIFFTAG_PIXARLOGQUALITY 65558 /* PixarLog uses same scale */ /* 65559 is allocated to Oceana Matrix */ #define TIFFTAG_DCSCLIPRECTANGLE 65559 /* area of image to acquire */ #define TIFFTAG_SGILOGDATAFMT 65560 /* SGILog user data format */ #define SGILOGDATAFMT_FLOAT 0 /* IEEE float samples */ #define SGILOGDATAFMT_16BIT 1 /* 16-bit samples */ #define SGILOGDATAFMT_RAW 2 /* uninterpreted data */ #define SGILOGDATAFMT_8BIT 3 /* 8-bit RGB monitor values */ #endif /* _TIFF_ */ netpbm-8.2/libtiff/tiffcomp.h0100660000076400000000000001415706747424643015315 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tiffcomp.h,v 1.1.1.1 1999/07/27 21:50:27 mike Exp $ */ /* * Copyright (c) 1990-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. */ #ifndef _COMPAT_ #define _COMPAT_ /* * This file contains a hodgepodge of definitions and * declarations that are needed to provide compatibility * between the native system and the base implementation * that the library assumes. * * NB: This file is a mess. */ /* * Setup basic type definitions and function declaratations. */ /* * Simplify Acorn RISC OS identifier (to avoid confusion with Acorn RISC iX * and with defunct Unix Risc OS) * No need to specify __arm - hey, Acorn might port the OS, no problem here! */ #ifdef __acornriscos #undef __acornriscos #endif #if defined(__acorn) && defined(__riscos) #define __acornriscos #endif #if defined(__MWERKS__) || defined(THINK_C) #include #include #endif #include #if defined(__PPCC__) || defined(__SC__) || defined(__MRC__) #include #elif !defined(__MWERKS__) && !defined(THINK_C) && !defined(__acornriscos) && !defined(applec) #include #endif #if defined(VMS) #include #include #elif !defined(__acornriscos) #include #endif /* * This maze of checks controls defines or not the * target system has BSD-style typdedefs declared in * an include file and/or whether or not to include * to get the SEEK_* definitions. Some * additional includes are also done to pull in the * appropriate definitions we're looking for. */ #if defined(__MWERKS__) || defined(THINK_C) || defined(__PPCC__) || defined(__SC__) || defined(__MRC__) #include #define BSDTYPES #define HAVE_UNISTD_H 0 #elif defined(_WINDOWS) || defined(__WIN32__) || defined(_Windows) #define BSDTYPES #elif defined(OS2_16) || defined(OS2_32) #define BSDTYPES #elif defined(__acornriscos) #include #define BSDTYPES #define HAVE_UNISTD_H 0 #elif defined(VMS) #define HAVE_UNISTD_H 0 #else #define HAVE_UNISTD_H 1 #endif /* * The library uses the ANSI C/POSIX SEEK_* * definitions that should be defined in unistd.h * (except on system where they are in stdio.h and * there is no unistd.h). */ #if !defined(SEEK_SET) && HAVE_UNISTD_H #include #endif /* * The library uses memset, memcpy, and memcmp. * ANSI C and System V define these in string.h. */ #include /* * The BSD typedefs are used throughout the library. * If your system doesn't have them in , * then define BSDTYPES in your Makefile. */ #if defined(BSDTYPES) typedef unsigned char u_char; typedef unsigned short u_short; typedef unsigned int u_int; typedef unsigned long u_long; #endif /* * dblparam_t is the type that a double precision * floating point value will have on the parameter * stack (when coerced by the compiler). */ /* Note: on MacPowerPC "extended" is undefined. So only use it for 68K-Macs */ #if defined(__SC__) || defined(THINK_C) typedef extended dblparam_t; #else typedef double dblparam_t; #endif /* * If your compiler supports inline functions, then * set INLINE appropriately to get the known hotspots * in the library expanded inline. */ #if defined(__GNUC__) #if defined(__STRICT_ANSI__) #define INLINE __inline__ #else #define INLINE inline #endif #else /* !__GNUC__ */ #define INLINE #endif /* * GLOBALDATA is a macro that is used to define global variables * private to the library. We use this indirection to hide * brain-damage in VAXC (and GCC) under VAX/VMS. In these * environments the macro places the variable in a non-shareable * program section, which ought to be done by default (sigh!) * * Apparently DEC are aware of the problem as this behaviour is the * default under VMS on AXP. * * The GNU C variant is untested. */ #if defined(VAX) && defined(VMS) #if defined(VAXC) #define GLOBALDATA(TYPE,NAME) extern noshare TYPE NAME #endif #if defined(__GNUC__) #define GLOBALDATA(TYPE,NAME) extern TYPE NAME \ asm("_$$PsectAttributes_NOSHR$$" #NAME) #endif #else /* !VAX/VMS */ #define GLOBALDATA(TYPE,NAME) extern TYPE NAME #endif #if defined(__acornriscos) /* * osfcn.h is part of C++Lib on Acorn C/C++, and as such can't be used * on C alone. For that reason, the relevant functions are * implemented in tif_acorn.c, and the elements from the header * file are included here. */ #if defined(__cplusplus) #include #else #define O_RDONLY 0 #define O_WRONLY 1 #define O_RDWR 2 #define O_APPEND 8 #define O_CREAT 0x200 #define O_TRUNC 0x400 typedef long off_t; extern int open(const char *name, int flags, int mode); extern int close(int fd); extern int write(int fd, const char *buf, int nbytes); extern int read(int fd, char *buf, int nbytes); extern off_t lseek(int fd, off_t offset, int whence); extern int creat(const char *path, int mode); #endif /* __cplusplus */ #endif /* __acornriscos */ /* Bit and byte order, the default is MSB to LSB */ #ifdef VMS #undef HOST_FILLORDER #undef HOST_BIGENDIAN #define HOST_FILLORDER FILLORDER_LSB2MSB #define HOST_BIGENDIAN 0 #endif #endif /* _COMPAT_ */ netpbm-8.2/libtiff/tiffconf.h0100660000076400000000000001173506747424643015303 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tiffconf.h,v 1.1.1.1 1999/07/27 21:50:27 mike Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #ifndef _TIFFCONF_ #define _TIFFCONF_ /* * Library Configuration Definitions. * * This file defines the default configuration for the library. * If the target system does not have make or a way to specify * #defines on the command line, this file can be edited to * configure the library. Otherwise, one can override portability * and configuration-related definitions from a Makefile or command * line by defining FEATURE_SUPPORT and COMPRESSION_SUPPORT (see below). */ /* * General portability-related defines: * * HAVE_IEEEFP define as 0 or 1 according to the floating point * format suported by the machine * BSDTYPES define this if your system does NOT define the * usual 4BSD typedefs u_int et. al. * HAVE_MMAP enable support for memory mapping read-only files; * this is typically deduced by the configure script * HOST_FILLORDER native cpu bit order: one of FILLORDER_MSB2LSB * or FILLODER_LSB2MSB; this is typically set by the * configure script * HOST_BIGENDIAN native cpu byte order: 1 if big-endian (Motorola) * or 0 if little-endian (Intel); this may be used * in codecs to optimize code */ #ifndef HAVE_IEEEFP #define HAVE_IEEEFP 1 #endif #ifndef HOST_FILLORDER #define HOST_FILLORDER FILLORDER_MSB2LSB #endif #ifndef HOST_BIGENDIAN #define HOST_BIGENDIAN 1 #endif #ifndef FEATURE_SUPPORT /* * Feature support definitions: * * COLORIMETRY_SUPPORT enable support for 6.0 colorimetry tags * YCBCR_SUPPORT enable support for 6.0 YCbCr tags * CMYK_SUPPORT enable support for 6.0 CMYK tags * ICC_SUPPORT enable support for ICC profile tag * PHOTOSHOP_SUPPORT enable support for PHOTOSHOP resource tag * IPTC_SUPPORT enable support for RichTIFF IPTC tag */ #define COLORIMETRY_SUPPORT #define YCBCR_SUPPORT #define CMYK_SUPPORT #define ICC_SUPPORT #define PHOTOSHOP_SUPPORT #define IPTC_SUPPORT #endif /* FEATURE_SUPPORT */ #ifndef COMPRESSION_SUPPORT /* * Compression support defines: * * CCITT_SUPPORT enable support for CCITT Group 3 & 4 algorithms * PACKBITS_SUPPORT enable support for Macintosh PackBits algorithm * LZW_SUPPORT enable support for LZW algorithm * THUNDER_SUPPORT enable support for ThunderScan 4-bit RLE algorithm * NEXT_SUPPORT enable support for NeXT 2-bit RLE algorithm * OJPEG_SUPPORT enable support for 6.0-style JPEG DCT algorithms * (no builtin support, only a codec hook) * JPEG_SUPPORT enable support for post-6.0-style JPEG DCT algorithms * (requires freely available IJG software, see tif_jpeg.c) * ZIP_SUPPORT enable support for Deflate algorithm * (requires freely available zlib software, see tif_zip.c) * PIXARLOG_SUPPORT enable support for Pixar log-format algorithm * LOGLUV_SUPPORT enable support for LogLuv high dynamic range encoding */ #define CCITT_SUPPORT #define PACKBITS_SUPPORT #define LZW_SUPPORT #define THUNDER_SUPPORT #define NEXT_SUPPORT #define LOGLUV_SUPPORT #endif /* COMPRESSION_SUPPORT */ /* * If JPEG compression is enabled then we must also include * support for the colorimetry and YCbCr-related tags. */ #ifdef JPEG_SUPPORT #ifndef YCBCR_SUPPORT #define YCBCR_SUPPORT #endif #ifndef COLORIMETRY_SUPPORT #define COLORIMETRY_SUPPORT #endif #endif /* JPEG_SUPPORT */ /* * ``Orthogonal Features'' * * STRIPCHOP_DEFAULT default handling of strip chopping support (whether * or not to convert single-strip uncompressed images * to mutiple strips of ~8Kb--to reduce memory use) * SUBIFD_SUPPORT enable support for SubIFD tag (thumbnails and such) */ #ifndef STRIPCHOP_DEFAULT #define STRIPCHOP_DEFAULT TIFF_STRIPCHOP /* default is to enable */ #endif #ifndef SUBIFD_SUPPORT #define SUBIFD_SUPPORT 1 /* enable SubIFD tag (330) support */ #endif #endif /* _TIFFCONF_ */ netpbm-8.2/libtiff/tiffio.h0100660000076400000000000003055406765452271014763 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tiffio.h,v 1.3 1999/09/08 12:21:13 warmerda Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #ifndef _TIFFIO_ #define _TIFFIO_ /* * TIFF I/O Library Definitions. */ #include "tiff.h" /* * This define can be used in code that requires * compilation-related definitions specific to a * version or versions of the library. Runtime * version checking should be done based on the * string returned by TIFFGetVersion. */ #define TIFFLIB_VERSION 19970127 /* January 27, 1997 */ /* * TIFF is defined as an incomplete type to hide the * library's internal data structures from clients. */ typedef struct tiff TIFF; /* * The following typedefs define the intrinsic size of * data types used in the *exported* interfaces. These * definitions depend on the proper definition of types * in tiff.h. Note also that the varargs interface used * to pass tag types and values uses the types defined in * tiff.h directly. * * NB: ttag_t is unsigned int and not unsigned short because * ANSI C requires that the type before the ellipsis be a * promoted type (i.e. one of int, unsigned int, pointer, * or double) and because we defined pseudo-tags that are * outside the range of legal Aldus-assigned tags. * NB: tsize_t is int32 and not uint32 because some functions * return -1. * NB: toff_t is not off_t for many reasons; TIFFs max out at * 32-bit file offsets being the most important */ typedef uint32 ttag_t; /* directory tag */ typedef uint16 tdir_t; /* directory index */ typedef uint16 tsample_t; /* sample number */ typedef uint32 tstrip_t; /* strip number */ typedef uint32 ttile_t; /* tile number */ typedef int32 tsize_t; /* i/o size in bytes */ typedef void* tdata_t; /* image data ref */ typedef int32 toff_t; /* file offset */ #if !defined(__WIN32__) && (defined(_WIN32) || defined(WIN32)) #define __WIN32__ #endif #if defined(_WINDOWS) || defined(__WIN32__) || defined(_Windows) #include #ifdef __WIN32__ DECLARE_HANDLE(thandle_t); /* Win32 file handle */ #else typedef HFILE thandle_t; /* client data handle */ #endif #else typedef void* thandle_t; /* client data handle */ #endif #ifndef NULL #define NULL 0 #endif /* * Flags to pass to TIFFPrintDirectory to control * printing of data structures that are potentially * very large. Bit-or these flags to enable printing * multiple items. */ #define TIFFPRINT_NONE 0x0 /* no extra info */ #define TIFFPRINT_STRIPS 0x1 /* strips/tiles info */ #define TIFFPRINT_CURVES 0x2 /* color/gray response curves */ #define TIFFPRINT_COLORMAP 0x4 /* colormap */ #define TIFFPRINT_JPEGQTABLES 0x100 /* JPEG Q matrices */ #define TIFFPRINT_JPEGACTABLES 0x200 /* JPEG AC tables */ #define TIFFPRINT_JPEGDCTABLES 0x200 /* JPEG DC tables */ /* * RGBA-style image support. */ typedef unsigned char TIFFRGBValue; /* 8-bit samples */ typedef struct _TIFFRGBAImage TIFFRGBAImage; /* * The image reading and conversion routines invoke * ``put routines'' to copy/image/whatever tiles of * raw image data. A default set of routines are * provided to convert/copy raw image data to 8-bit * packed ABGR format rasters. Applications can supply * alternate routines that unpack the data into a * different format or, for example, unpack the data * and draw the unpacked raster on the display. */ typedef void (*tileContigRoutine) (TIFFRGBAImage*, uint32*, uint32, uint32, uint32, uint32, int32, int32, unsigned char*); typedef void (*tileSeparateRoutine) (TIFFRGBAImage*, uint32*, uint32, uint32, uint32, uint32, int32, int32, unsigned char*, unsigned char*, unsigned char*, unsigned char*); /* * RGBA-reader state. */ typedef struct { /* YCbCr->RGB support */ TIFFRGBValue* clamptab; /* range clamping table */ int* Cr_r_tab; int* Cb_b_tab; int32* Cr_g_tab; int32* Cb_g_tab; float coeffs[3]; /* cached for repeated use */ } TIFFYCbCrToRGB; struct _TIFFRGBAImage { TIFF* tif; /* image handle */ int stoponerr; /* stop on read error */ int isContig; /* data is packed/separate */ int alpha; /* type of alpha data present */ uint32 width; /* image width */ uint32 height; /* image height */ uint16 bitspersample; /* image bits/sample */ uint16 samplesperpixel; /* image samples/pixel */ uint16 orientation; /* image orientation */ uint16 photometric; /* image photometric interp */ uint16* redcmap; /* colormap pallete */ uint16* greencmap; uint16* bluecmap; /* get image data routine */ int (*get)(TIFFRGBAImage*, uint32*, uint32, uint32); union { void (*any)(TIFFRGBAImage*); tileContigRoutine contig; tileSeparateRoutine separate; } put; /* put decoded strip/tile */ TIFFRGBValue* Map; /* sample mapping array */ uint32** BWmap; /* black&white map */ uint32** PALmap; /* palette image map */ TIFFYCbCrToRGB* ycbcr; /* YCbCr conversion state */ int row_offset; int col_offset; }; /* * Macros for extracting components from the * packed ABGR form returned by TIFFReadRGBAImage. */ #define TIFFGetR(abgr) ((abgr) & 0xff) #define TIFFGetG(abgr) (((abgr) >> 8) & 0xff) #define TIFFGetB(abgr) (((abgr) >> 16) & 0xff) #define TIFFGetA(abgr) (((abgr) >> 24) & 0xff) /* * A CODEC is a software package that implements decoding, * encoding, or decoding+encoding of a compression algorithm. * The library provides a collection of builtin codecs. * More codecs may be registered through calls to the library * and/or the builtin implementations may be overridden. */ typedef int (*TIFFInitMethod)(TIFF*, int); typedef struct { char* name; uint16 scheme; TIFFInitMethod init; } TIFFCodec; #include #include #if defined(__cplusplus) extern "C" { #endif typedef void (*TIFFErrorHandler)(const char*, const char*, va_list); typedef tsize_t (*TIFFReadWriteProc)(thandle_t, tdata_t, tsize_t); typedef toff_t (*TIFFSeekProc)(thandle_t, toff_t, int); typedef int (*TIFFCloseProc)(thandle_t); typedef toff_t (*TIFFSizeProc)(thandle_t); typedef int (*TIFFMapFileProc)(thandle_t, tdata_t*, toff_t*); typedef void (*TIFFUnmapFileProc)(thandle_t, tdata_t, toff_t); typedef void (*TIFFExtendProc)(TIFF*); extern const char* TIFFGetVersion(void); extern const TIFFCodec* TIFFFindCODEC(uint16); extern TIFFCodec* TIFFRegisterCODEC(uint16, const char*, TIFFInitMethod); extern void TIFFUnRegisterCODEC(TIFFCodec*); extern tdata_t _TIFFmalloc(tsize_t); extern tdata_t _TIFFrealloc(tdata_t, tsize_t); extern void _TIFFmemset(tdata_t, int, tsize_t); extern void _TIFFmemcpy(tdata_t, const tdata_t, tsize_t); extern int _TIFFmemcmp(const tdata_t, const tdata_t, tsize_t); extern void _TIFFfree(tdata_t); extern void TIFFClose(TIFF*); extern int TIFFFlush(TIFF*); extern int TIFFFlushData(TIFF*); extern int TIFFGetField(TIFF*, ttag_t, ...); extern int TIFFVGetField(TIFF*, ttag_t, va_list); extern int TIFFGetFieldDefaulted(TIFF*, ttag_t, ...); extern int TIFFVGetFieldDefaulted(TIFF*, ttag_t, va_list); extern int TIFFReadDirectory(TIFF*); extern tsize_t TIFFScanlineSize(TIFF*); extern tsize_t TIFFRasterScanlineSize(TIFF*); extern tsize_t TIFFStripSize(TIFF*); extern tsize_t TIFFVStripSize(TIFF*, uint32); extern tsize_t TIFFTileRowSize(TIFF*); extern tsize_t TIFFTileSize(TIFF*); extern tsize_t TIFFVTileSize(TIFF*, uint32); extern uint32 TIFFDefaultStripSize(TIFF*, uint32); extern void TIFFDefaultTileSize(TIFF*, uint32*, uint32*); extern int TIFFFileno(TIFF*); extern int TIFFGetMode(TIFF*); extern int TIFFIsTiled(TIFF*); extern int TIFFIsByteSwapped(TIFF*); extern int TIFFIsUpSampled(TIFF*); extern int TIFFIsMSB2LSB(TIFF*); extern uint32 TIFFCurrentRow(TIFF*); extern tdir_t TIFFCurrentDirectory(TIFF*); extern tdir_t TIFFNumberOfDirectories(TIFF*); extern uint32 TIFFCurrentDirOffset(TIFF*); extern tstrip_t TIFFCurrentStrip(TIFF*); extern ttile_t TIFFCurrentTile(TIFF*); extern int TIFFReadBufferSetup(TIFF*, tdata_t, tsize_t); extern int TIFFWriteBufferSetup(TIFF*, tdata_t, tsize_t); extern int TIFFLastDirectory(TIFF*); extern int TIFFSetDirectory(TIFF*, tdir_t); extern int TIFFSetSubDirectory(TIFF*, uint32); extern int TIFFUnlinkDirectory(TIFF*, tdir_t); extern int TIFFSetField(TIFF*, ttag_t, ...); extern int TIFFVSetField(TIFF*, ttag_t, va_list); extern int TIFFWriteDirectory(TIFF *); extern int TIFFReassignTagToIgnore(enum TIFFIgnoreSense, int); #if defined(c_plusplus) || defined(__cplusplus) extern void TIFFPrintDirectory(TIFF*, FILE*, long = 0); extern int TIFFReadScanline(TIFF*, tdata_t, uint32, tsample_t = 0); extern int TIFFWriteScanline(TIFF*, tdata_t, uint32, tsample_t = 0); extern int TIFFReadRGBAImage(TIFF*, uint32, uint32, uint32*, int = 0); #else extern void TIFFPrintDirectory(TIFF*, FILE*, long); extern int TIFFReadScanline(TIFF*, tdata_t, uint32, tsample_t); extern int TIFFWriteScanline(TIFF*, tdata_t, uint32, tsample_t); extern int TIFFReadRGBAImage(TIFF*, uint32, uint32, uint32*, int); #endif extern int TIFFReadRGBAStrip(TIFF*, tstrip_t, uint32 * ); extern int TIFFReadRGBATile(TIFF*, uint32, uint32, uint32 * ); extern int TIFFRGBAImageOK(TIFF*, char [1024]); extern int TIFFRGBAImageBegin(TIFFRGBAImage*, TIFF*, int, char [1024]); extern int TIFFRGBAImageGet(TIFFRGBAImage*, uint32*, uint32, uint32); extern void TIFFRGBAImageEnd(TIFFRGBAImage*); extern TIFF* TIFFOpen(const char*, const char*); extern TIFF* TIFFFdOpen(int, const char*, const char*); extern TIFF* TIFFClientOpen(const char*, const char*, thandle_t, TIFFReadWriteProc, TIFFReadWriteProc, TIFFSeekProc, TIFFCloseProc, TIFFSizeProc, TIFFMapFileProc, TIFFUnmapFileProc); extern const char* TIFFFileName(TIFF*); extern void TIFFError(const char*, const char*, ...); extern void TIFFWarning(const char*, const char*, ...); extern TIFFErrorHandler TIFFSetErrorHandler(TIFFErrorHandler); extern TIFFErrorHandler TIFFSetWarningHandler(TIFFErrorHandler); extern TIFFExtendProc TIFFSetTagExtender(TIFFExtendProc); extern ttile_t TIFFComputeTile(TIFF*, uint32, uint32, uint32, tsample_t); extern int TIFFCheckTile(TIFF*, uint32, uint32, uint32, tsample_t); extern ttile_t TIFFNumberOfTiles(TIFF*); extern tsize_t TIFFReadTile(TIFF*, tdata_t, uint32, uint32, uint32, tsample_t); extern tsize_t TIFFWriteTile(TIFF*, tdata_t, uint32, uint32, uint32, tsample_t); extern tstrip_t TIFFComputeStrip(TIFF*, uint32, tsample_t); extern tstrip_t TIFFNumberOfStrips(TIFF*); extern tsize_t TIFFReadEncodedStrip(TIFF*, tstrip_t, tdata_t, tsize_t); extern tsize_t TIFFReadRawStrip(TIFF*, tstrip_t, tdata_t, tsize_t); extern tsize_t TIFFReadEncodedTile(TIFF*, ttile_t, tdata_t, tsize_t); extern tsize_t TIFFReadRawTile(TIFF*, ttile_t, tdata_t, tsize_t); extern tsize_t TIFFWriteEncodedStrip(TIFF*, tstrip_t, tdata_t, tsize_t); extern tsize_t TIFFWriteRawStrip(TIFF*, tstrip_t, tdata_t, tsize_t); extern tsize_t TIFFWriteEncodedTile(TIFF*, ttile_t, tdata_t, tsize_t); extern tsize_t TIFFWriteRawTile(TIFF*, ttile_t, tdata_t, tsize_t); extern void TIFFSetWriteOffset(TIFF*, toff_t); extern void TIFFSwabShort(uint16*); extern void TIFFSwabLong(uint32*); extern void TIFFSwabDouble(double*); extern void TIFFSwabArrayOfShort(uint16*, unsigned long); extern void TIFFSwabArrayOfLong(uint32*, unsigned long); extern void TIFFSwabArrayOfDouble(double*, unsigned long); extern void TIFFReverseBits(unsigned char *, unsigned long); extern const unsigned char* TIFFGetBitRevTable(int); #if defined(__cplusplus) } #endif #endif /* _TIFFIO_ */ netpbm-8.2/libtiff/tiffiop.h0100660000076400000000000002643707016343774015145 0ustar bryanhroot/* $Header: /cvsroot/osrs/libtiff/libtiff/tiffiop.h,v 1.2 1999/11/22 22:47:24 mwelles Exp $ */ /* * Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1991-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #ifndef _TIFFIOP_ #define _TIFFIOP_ /* * ``Library-private'' definitions. */ /* * UNIX systems should run the configure script to generate * a port.h file that reflects the system capabilities. * Doing this obviates all the dreck done in tiffcomp.h. */ #if defined(unix) || defined(__unix) #include "port.h" #include "tiffconf.h" #else #include "tiffconf.h" #include "tiffcomp.h" #endif #include "tiffio.h" #include "tif_dir.h" #ifndef TRUE #define TRUE 1 #define FALSE 0 #endif /* * Typedefs for ``method pointers'' used internally. */ typedef unsigned char tidataval_t; /* internal image data value type */ typedef tidataval_t* tidata_t; /* reference to internal image data */ typedef void (*TIFFVoidMethod)(TIFF*); typedef int (*TIFFBoolMethod)(TIFF*); typedef int (*TIFFPreMethod)(TIFF*, tsample_t); typedef int (*TIFFCodeMethod)(TIFF*, tidata_t, tsize_t, tsample_t); typedef int (*TIFFSeekMethod)(TIFF*, uint32); typedef void (*TIFFPostMethod)(TIFF*, tidata_t, tsize_t); typedef int (*TIFFVSetMethod)(TIFF*, ttag_t, va_list); typedef int (*TIFFVGetMethod)(TIFF*, ttag_t, va_list); typedef void (*TIFFPrintMethod)(TIFF*, FILE*, long); typedef uint32 (*TIFFStripMethod)(TIFF*, uint32); typedef void (*TIFFTileMethod)(TIFF*, uint32*, uint32*); struct tiff { char* tif_name; /* name of open file */ int tif_fd; /* open file descriptor */ int tif_mode; /* open mode (O_*) */ uint32 tif_flags; #define TIFF_FILLORDER 0x0003 /* natural bit fill order for machine */ #define TIFF_DIRTYHEADER 0x0004 /* header must be written on close */ #define TIFF_DIRTYDIRECT 0x0008 /* current directory must be written */ #define TIFF_BUFFERSETUP 0x0010 /* data buffers setup */ #define TIFF_CODERSETUP 0x0020 /* encoder/decoder setup done */ #define TIFF_BEENWRITING 0x0040 /* written 1+ scanlines to file */ #define TIFF_SWAB 0x0080 /* byte swap file information */ #define TIFF_NOBITREV 0x0100 /* inhibit bit reversal logic */ #define TIFF_MYBUFFER 0x0200 /* my raw data buffer; free on close */ #define TIFF_ISTILED 0x0400 /* file is tile, not strip- based */ #define TIFF_MAPPED 0x0800 /* file is mapped into memory */ #define TIFF_POSTENCODE 0x1000 /* need call to postencode routine */ #define TIFF_INSUBIFD 0x2000 /* currently writing a subifd */ #define TIFF_UPSAMPLED 0x4000 /* library is doing data up-sampling */ #define TIFF_STRIPCHOP 0x8000 /* enable strip chopping support */ toff_t tif_diroff; /* file offset of current directory */ toff_t tif_nextdiroff; /* file offset of following directory */ TIFFDirectory tif_dir; /* internal rep of current directory */ TIFFHeader tif_header; /* file's header block */ tidata_t tif_clientdir; /* client TIFF directory */ const int* tif_typeshift; /* data type shift counts */ const long* tif_typemask; /* data type masks */ uint32 tif_row; /* current scanline */ tdir_t tif_curdir; /* current directory (index) */ tstrip_t tif_curstrip; /* current strip for read/write */ toff_t tif_curoff; /* current offset for read/write */ toff_t tif_dataoff; /* current offset for writing dir */ #if SUBIFD_SUPPORT uint16 tif_nsubifd; /* remaining subifds to write */ toff_t tif_subifdoff; /* offset for patching SubIFD link */ #endif /* tiling support */ uint32 tif_col; /* current column (offset by row too) */ ttile_t tif_curtile; /* current tile for read/write */ tsize_t tif_tilesize; /* # of bytes in a tile */ /* compression scheme hooks */ TIFFBoolMethod tif_setupdecode;/* called once before predecode */ TIFFPreMethod tif_predecode; /* pre- row/strip/tile decoding */ TIFFBoolMethod tif_setupencode;/* called once before preencode */ TIFFPreMethod tif_preencode; /* pre- row/strip/tile encoding */ TIFFBoolMethod tif_postencode; /* post- row/strip/tile encoding */ TIFFCodeMethod tif_decoderow; /* scanline decoding routine */ TIFFCodeMethod tif_encoderow; /* scanline encoding routine */ TIFFCodeMethod tif_decodestrip;/* strip decoding routine */ TIFFCodeMethod tif_encodestrip;/* strip encoding routine */ TIFFCodeMethod tif_decodetile; /* tile decoding routine */ TIFFCodeMethod tif_encodetile; /* tile encoding routine */ TIFFVoidMethod tif_close; /* cleanup-on-close routine */ TIFFSeekMethod tif_seek; /* position within a strip routine */ TIFFVoidMethod tif_cleanup; /* cleanup state routine */ TIFFStripMethod tif_defstripsize;/* calculate/constrain strip size */ TIFFTileMethod tif_deftilesize;/* calculate/constrain tile size */ tidata_t tif_data; /* compression scheme private data */ /* input/output buffering */ tsize_t tif_scanlinesize;/* # of bytes in a scanline */ tsize_t tif_scanlineskew;/* scanline skew for reading strips */ tidata_t tif_rawdata; /* raw data buffer */ tsize_t tif_rawdatasize;/* # of bytes in raw data buffer */ tidata_t tif_rawcp; /* current spot in raw buffer */ tsize_t tif_rawcc; /* bytes unread from raw buffer */ /* memory-mapped file support */ tidata_t tif_base; /* base of mapped file */ toff_t tif_size; /* size of mapped file region (bytes) */ TIFFMapFileProc tif_mapproc; /* map file method */ TIFFUnmapFileProc tif_unmapproc;/* unmap file method */ /* input/output callback methods */ thandle_t tif_clientdata; /* callback parameter */ TIFFReadWriteProc tif_readproc; /* read method */ TIFFReadWriteProc tif_writeproc;/* write method */ TIFFSeekProc tif_seekproc; /* lseek method */ TIFFCloseProc tif_closeproc; /* close method */ TIFFSizeProc tif_sizeproc; /* filesize method */ /* post-decoding support */ TIFFPostMethod tif_postdecode; /* post decoding routine */ /* tag support */ TIFFFieldInfo** tif_fieldinfo; /* sorted table of registered tags */ int tif_nfields; /* # entries in registered tag table */ TIFFVSetMethod tif_vsetfield; /* tag set routine */ TIFFVGetMethod tif_vgetfield; /* tag get routine */ TIFFPrintMethod tif_printdir; /* directory print routine */ }; #define isPseudoTag(t) (t > 0xffff) /* is tag value normal or pseudo */ #define isTiled(tif) (((tif)->tif_flags & TIFF_ISTILED) != 0) #define isMapped(tif) (((tif)->tif_flags & TIFF_MAPPED) != 0) #define isFillOrder(tif, o) (((tif)->tif_flags & (o)) != 0) #define isUpSampled(tif) (((tif)->tif_flags & TIFF_UPSAMPLED) != 0) #define TIFFReadFile(tif, buf, size) \ ((*(tif)->tif_readproc)((tif)->tif_clientdata,buf,size)) #define TIFFWriteFile(tif, buf, size) \ ((*(tif)->tif_writeproc)((tif)->tif_clientdata,buf,size)) #define TIFFSeekFile(tif, off, whence) \ ((*(tif)->tif_seekproc)((tif)->tif_clientdata,(toff_t)(off),whence)) #define TIFFCloseFile(tif) \ ((*(tif)->tif_closeproc)((tif)->tif_clientdata)) #define TIFFGetFileSize(tif) \ ((*(tif)->tif_sizeproc)((tif)->tif_clientdata)) #define TIFFMapFileContents(tif, paddr, psize) \ ((*(tif)->tif_mapproc)((tif)->tif_clientdata,paddr,psize)) #define TIFFUnmapFileContents(tif, addr, size) \ ((*(tif)->tif_unmapproc)((tif)->tif_clientdata,addr,size)) /* * Default Read/Seek/Write definitions. */ #ifndef ReadOK #define ReadOK(tif, buf, size) \ (TIFFReadFile(tif, (tdata_t) buf, (tsize_t) size) == (tsize_t) size) #endif #ifndef SeekOK #define SeekOK(tif, off) \ (TIFFSeekFile(tif, (toff_t) off, SEEK_SET) == (toff_t) off) #endif #ifndef WriteOK #define WriteOK(tif, buf, size) \ (TIFFWriteFile(tif, (tdata_t) buf, (tsize_t) size) == (tsize_t) size) #endif /* NB: the uint32 casts are to silence certain ANSI-C compilers */ #define TIFFhowmany(x, y) ((((uint32)(x))+(((uint32)(y))-1))/((uint32)(y))) #define TIFFroundup(x, y) (TIFFhowmany(x,y)*((uint32)(y))) #if defined(__cplusplus) extern "C" { #endif extern int _TIFFgetMode(const char*, const char*); extern int _TIFFNoRowEncode(TIFF*, tidata_t, tsize_t, tsample_t); extern int _TIFFNoStripEncode(TIFF*, tidata_t, tsize_t, tsample_t); extern int _TIFFNoTileEncode(TIFF*, tidata_t, tsize_t, tsample_t); extern int _TIFFNoRowDecode(TIFF*, tidata_t, tsize_t, tsample_t); extern int _TIFFNoStripDecode(TIFF*, tidata_t, tsize_t, tsample_t); extern int _TIFFNoTileDecode(TIFF*, tidata_t, tsize_t, tsample_t); extern void _TIFFNoPostDecode(TIFF*, tidata_t, tsize_t); extern int _TIFFNoPreCode (TIFF*, tsample_t); extern int _TIFFNoSeek(TIFF*, uint32); extern void _TIFFSwab16BitData(TIFF*, tidata_t, tsize_t); extern void _TIFFSwab32BitData(TIFF*, tidata_t, tsize_t); extern void _TIFFSwab64BitData(TIFF*, tidata_t, tsize_t); extern int TIFFFlushData1(TIFF*); extern void TIFFFreeDirectory(TIFF*); extern int TIFFDefaultDirectory(TIFF*); extern int TIFFSetCompressionScheme(TIFF*, int); extern int TIFFSetDefaultCompressionState(TIFF*); extern uint32 _TIFFDefaultStripSize(TIFF*, uint32); extern void _TIFFDefaultTileSize(TIFF*, uint32*, uint32*); extern void _TIFFsetByteArray(void**, void*, long); extern void _TIFFsetString(char**, char*); extern void _TIFFsetShortArray(uint16**, uint16*, long); extern void _TIFFsetLongArray(uint32**, uint32*, long); extern void _TIFFsetFloatArray(float**, float*, long); extern void _TIFFsetDoubleArray(double**, double*, long); extern void _TIFFprintAscii(FILE*, const char*); extern void _TIFFprintAsciiTag(FILE*, const char*, const char*); GLOBALDATA(TIFFErrorHandler,_TIFFwarningHandler); GLOBALDATA(TIFFErrorHandler,_TIFFerrorHandler); extern int TIFFInitDumpMode(TIFF*, int); #ifdef PACKBITS_SUPPORT extern int TIFFInitPackBits(TIFF*, int); #endif #ifdef CCITT_SUPPORT extern int TIFFInitCCITTRLE(TIFF*, int), TIFFInitCCITTRLEW(TIFF*, int); extern int TIFFInitCCITTFax3(TIFF*, int), TIFFInitCCITTFax4(TIFF*, int); #endif #ifdef THUNDER_SUPPORT extern int TIFFInitThunderScan(TIFF*, int); #endif #ifdef NEXT_SUPPORT extern int TIFFInitNeXT(TIFF*, int); #endif #ifdef LZW_SUPPORT extern int TIFFInitLZW(TIFF*, int); #endif #ifdef OJPEG_SUPPORT extern int TIFFInitOJPEG(TIFF*, int); #endif #ifdef JPEG_SUPPORT extern int TIFFInitJPEG(TIFF*, int); #endif #ifdef JBIG_SUPPORT extern int TIFFInitJBIG(TIFF*, int); #endif #ifdef ZIP_SUPPORT extern int TIFFInitZIP(TIFF*, int); #endif #ifdef PIXARLOG_SUPPORT extern int TIFFInitPixarLog(TIFF*, int); #endif #ifdef LOGLUV_SUPPORT extern int TIFFInitSGILog(TIFF*, int); #endif #ifdef VMS extern const TIFFCodec _TIFFBuiltinCODECS[]; #else extern TIFFCodec _TIFFBuiltinCODECS[]; #endif #if defined(__cplusplus) } #endif #endif /* _TIFFIOP_ */ netpbm-8.2/libtiff/uvcode.h0100660000076400000000000001144107020047745014751 0ustar bryanhroot/* Version 1.0 generated April 7, 1997 by Greg Ward Larson, SGI */ #define UV_SQSIZ (float)0.003500 #define UV_NDIVS 16289 #define UV_VSTART (float)0.016940 #define UV_NVS 163 static struct { float ustart; short nus, ncum; } uv_row[UV_NVS] = { (float)0.247663, 4, 0, (float)0.243779, 6, 4, (float)0.241684, 7, 10, (float)0.237874, 9, 17, (float)0.235906, 10, 26, (float)0.232153, 12, 36, (float)0.228352, 14, 48, (float)0.226259, 15, 62, (float)0.222371, 17, 77, (float)0.220410, 18, 94, (float)0.214710, 21, 112, (float)0.212714, 22, 133, (float)0.210721, 23, 155, (float)0.204976, 26, 178, (float)0.202986, 27, 204, (float)0.199245, 29, 231, (float)0.195525, 31, 260, (float)0.193560, 32, 291, (float)0.189878, 34, 323, (float)0.186216, 36, 357, (float)0.186216, 36, 393, (float)0.182592, 38, 429, (float)0.179003, 40, 467, (float)0.175466, 42, 507, (float)0.172001, 44, 549, (float)0.172001, 44, 593, (float)0.168612, 46, 637, (float)0.168612, 46, 683, (float)0.163575, 49, 729, (float)0.158642, 52, 778, (float)0.158642, 52, 830, (float)0.158642, 52, 882, (float)0.153815, 55, 934, (float)0.153815, 55, 989, (float)0.149097, 58, 1044, (float)0.149097, 58, 1102, (float)0.142746, 62, 1160, (float)0.142746, 62, 1222, (float)0.142746, 62, 1284, (float)0.138270, 65, 1346, (float)0.138270, 65, 1411, (float)0.138270, 65, 1476, (float)0.132166, 69, 1541, (float)0.132166, 69, 1610, (float)0.126204, 73, 1679, (float)0.126204, 73, 1752, (float)0.126204, 73, 1825, (float)0.120381, 77, 1898, (float)0.120381, 77, 1975, (float)0.120381, 77, 2052, (float)0.120381, 77, 2129, (float)0.112962, 82, 2206, (float)0.112962, 82, 2288, (float)0.112962, 82, 2370, (float)0.107450, 86, 2452, (float)0.107450, 86, 2538, (float)0.107450, 86, 2624, (float)0.107450, 86, 2710, (float)0.100343, 91, 2796, (float)0.100343, 91, 2887, (float)0.100343, 91, 2978, (float)0.095126, 95, 3069, (float)0.095126, 95, 3164, (float)0.095126, 95, 3259, (float)0.095126, 95, 3354, (float)0.088276, 100, 3449, (float)0.088276, 100, 3549, (float)0.088276, 100, 3649, (float)0.088276, 100, 3749, (float)0.081523, 105, 3849, (float)0.081523, 105, 3954, (float)0.081523, 105, 4059, (float)0.081523, 105, 4164, (float)0.074861, 110, 4269, (float)0.074861, 110, 4379, (float)0.074861, 110, 4489, (float)0.074861, 110, 4599, (float)0.068290, 115, 4709, (float)0.068290, 115, 4824, (float)0.068290, 115, 4939, (float)0.068290, 115, 5054, (float)0.063573, 119, 5169, (float)0.063573, 119, 5288, (float)0.063573, 119, 5407, (float)0.063573, 119, 5526, (float)0.057219, 124, 5645, (float)0.057219, 124, 5769, (float)0.057219, 124, 5893, (float)0.057219, 124, 6017, (float)0.050985, 129, 6141, (float)0.050985, 129, 6270, (float)0.050985, 129, 6399, (float)0.050985, 129, 6528, (float)0.050985, 129, 6657, (float)0.044859, 134, 6786, (float)0.044859, 134, 6920, (float)0.044859, 134, 7054, (float)0.044859, 134, 7188, (float)0.040571, 138, 7322, (float)0.040571, 138, 7460, (float)0.040571, 138, 7598, (float)0.040571, 138, 7736, (float)0.036339, 142, 7874, (float)0.036339, 142, 8016, (float)0.036339, 142, 8158, (float)0.036339, 142, 8300, (float)0.032139, 146, 8442, (float)0.032139, 146, 8588, (float)0.032139, 146, 8734, (float)0.032139, 146, 8880, (float)0.027947, 150, 9026, (float)0.027947, 150, 9176, (float)0.027947, 150, 9326, (float)0.023739, 154, 9476, (float)0.023739, 154, 9630, (float)0.023739, 154, 9784, (float)0.023739, 154, 9938, (float)0.019504, 158, 10092, (float)0.019504, 158, 10250, (float)0.019504, 158, 10408, (float)0.016976, 161, 10566, (float)0.016976, 161, 10727, (float)0.016976, 161, 10888, (float)0.016976, 161, 11049, (float)0.012639, 165, 11210, (float)0.012639, 165, 11375, (float)0.012639, 165, 11540, (float)0.009991, 168, 11705, (float)0.009991, 168, 11873, (float)0.009991, 168, 12041, (float)0.009016, 170, 12209, (float)0.009016, 170, 12379, (float)0.009016, 170, 12549, (float)0.006217, 173, 12719, (float)0.006217, 173, 12892, (float)0.005097, 175, 13065, (float)0.005097, 175, 13240, (float)0.005097, 175, 13415, (float)0.003909, 177, 13590, (float)0.003909, 177, 13767, (float)0.002340, 177, 13944, (float)0.002389, 170, 14121, (float)0.001068, 164, 14291, (float)0.001653, 157, 14455, (float)0.000717, 150, 14612, (float)0.001614, 143, 14762, (float)0.000270, 136, 14905, (float)0.000484, 129, 15041, (float)0.001103, 123, 15170, (float)0.001242, 115, 15293, (float)0.001188, 109, 15408, (float)0.001011, 103, 15517, (float)0.000709, 97, 15620, (float)0.000301, 89, 15717, (float)0.002416, 82, 15806, (float)0.003251, 76, 15888, (float)0.003246, 69, 15964, (float)0.004141, 62, 16033, (float)0.005963, 55, 16095, (float)0.008839, 47, 16150, (float)0.010490, 40, 16197, (float)0.016994, 31, 16237, (float)0.023659, 21, 16268, }; netpbm-8.2/libtiff/version.h0100660000076400000000000000017607060313627015153 0ustar bryanhroot#define VERSION "LIBTIFF, Version 3.5.4\nCopyright (c) 1988-1996 Sam Leffler\nCopyright (c) 1991-1996 Silicon Graphics, Inc." netpbm-8.2/magic0100660000076400000000000000232005534607445012702 0ustar bryanhroot# PBMPLUS auxiliary magic numbers file # # These are meant to be used with the "file" program to help determine # the type of a file. You can add these entries to the system's /etc/magic # file, or if your version of "file" supports the -m flag you can use # them that way. # # All of these entries use the "string" format so that they will work on # both big-endian and little-endian machines. 0 string \037\235 compressed file 0 string begin uuencoded file 0 string xbtoa btoa'd file 0 string P1 PBM file 0 string P2 PGM file 0 string P3 PPM file 0 string P4 PBM "rawbits" file 0 string P5 PGM "rawbits" file 0 string P6 PPM "rawbits" file 0 string \361\0\100\273 CMU window manager bitmap 0 string \131\246\152\225 Sun rasterfile 0 string yz MGR bitmap 0 string \115\115 TIFF file, big-endian 0 string \111\111 TIFF file, little-endian 0 string GIF87a GIF file 0 string GIF89a GIF file 8 string ILBM IFF ILBM file 0 string This\040is\040a\040BitMap\040file Lisp Machine bit-array-file 0 string !! Bennet Yee's "face" format 0 string \117\072 Solitaire Image Recorder format >4 string \013 MGI Type 11 >4 string \021 MGI Type 17 0 string \1\332 SGI image file netpbm-8.2/mantocat0100770000076400000000000000045505453764456013447 0ustar bryanhroot#!/bin/sh # # Shell script which reads the man pages in nroff format, calls nroff, and produces cat files. # # Syntax: mancp source dest # # Example: mancp pgm.5 /usr/local/man/cat5/pgm.0 # # Oliver Trepte, 93-07-05 # # TMP=/tmp/mancp$$ nroff -man $1 > $TMP cp $TMP $2 rm -f $TMP echo "Done with $2" netpbm-8.2/pbm/0040550000076400000000000000000007065511103012440 5ustar bryanhrootnetpbm-8.2/pbm/pbmtoln03.10100660000076400000000000000122005453764172014354 0ustar bryanhroot.TH pbmtoln03 1 "7 May 1993" .IX pbmtoln03 .SH NAME pbmtoln03 - convert protable bitmap to DEC LN03+ Sixel output .SH SYNOPSIS .B pbmtoln03 .RB [ -rltbf ] .I pbmfile .SH DESCRIPTION Reads a portable bitmap as input. .IX "DEC LN03+ Sixel" Produces a DEC LN03+ Sixel output file. .SH OPTIONS .TP .B -l nn Use "nn" as value for left margin (default 0). .TP .B -r nn Use "nn" as value for right margin (default 2400). .TP .B -t nn Use "nn" as value for top margin (default 0). .TP .B -b nn Use "nn" as value for bottom margin (default 3400). .TP .B -f nn Use "nn" as value for form length (default 3400). .SH "SEE ALSO" pbm(5) .SH AUTHOR Tim Cook, 26 Feb 1992 netpbm-8.2/pbm/pbmtoln03.c0100660000076400000000000001601207065051742014434 0ustar bryanhroot/* From tim@deakin.edu.au Fri May 7 00:18:57 1993 From: Tim Cook Date: Fri, 7 May 1993 15:18:34 -0500 X-Mailer: Mail User's Shell (7.2.4 2/2/92) To: dyson@sunfish.Physics.UIowa.Edu Subject: Re: DEC LN03+ printer (not postscript) under SunOS (on SS10) ? Content-Length: 5893 In a message dated 6 May, 9:32, dyson@sunfish.Physics.UIowa.Edu (Richard L. Dyson) wrote: > > Just in case anyone is interested, I have a pbmtoln03 utility I wrote > > when I was mucking about with an LN03+. If you are interested in > > printing your bitmaps at 300x300dpi, ask me for the source. > > I would be interested. We still only have LN03+ printers on our VMS > machines here... Ok, here goes. Note that you will need the source from the pbmplus utilities, because my pbmtoln03 utility uses the library routines that are a part of pbmplus to read a PBM file (I linked it with libpbm.a). I have not tested this utility on VMS, but it looks like it should work. */ /* pbmtoln03.c - Converts a PBM bitmap to DEC LN03 SIXEL bitmap * * SYNOPSIS * pbmtoln03 [pbm-file] * * OPTIONS * -l nn Use "nn" as value for left margin (default 0). * -r nn Use "nn" as value for right margin (default 2400). * -t nn Use "nn" as value for top margin (default 0). * -b nn Use "nn" as value for bottom margin (default 3400). * -f nn Use "nn" as value for form length (default 3400). * * Tim Cook, 26 Feb 1992 * changed option parsing to PBM standards - Ingo Wilken, 13 Oct 1993 */ #include #include "pbm.h" FILE *input ; #ifndef print #define print(s) fputs (s, stdout) #define fprint(f, s) fputs (s, f) #endif /* prototypes */ void output_sixel_record ARGS((unsigned char *record, int width)); void convert ARGS((int width, int height, int format)); void output_sixel_record (record, width) unsigned char *record ; int width ; { int i, j, k ; unsigned char last_char ; int start_repeat = 0 ; int repeated ; char repeated_str[16] ; char *p ; /* Do RLE */ last_char = record[0] ; j = 0 ; /* This will make the following loop complete */ record[width] = '\0' ; for (i = 1 ; i <= width ; i++) { repeated = i - start_repeat ; if (record[i] != last_char || repeated >= 32766) { /* Repeat has ended */ if (repeated > 3) { /* Do an encoding */ record[j++] = '!' ; sprintf (repeated_str, "%d", i - start_repeat) ; for (p = repeated_str ; *p ; p++) record[j++] = *p ; record[j++] = last_char ; } else { for (k = 0 ; k < repeated ; k++) record[j++] = last_char ; } start_repeat = i ; last_char = record[i] ; } } fwrite ((char *) record, j, 1, stdout) ; putchar ('-') ; /* DECGNL (graphics new-line) */ putchar ('\n') ; } void convert (width, height, format) int width ; int height ; int format ; { register int i ; unsigned char *sixel ; /* A row of sixels */ int sixel_row ; bit *row = pbm_allocrow (width) ; sixel = (unsigned char *) malloc (width + 2) ; sixel_row = 0 ; while (height--) { pbm_readpbmrow (input, row, width, format) ; switch (sixel_row) { case 0 : for (i = 0 ; i < width ; i++) sixel[i] = row[i] ; break ; case 1 : for (i = 0 ; i < width ; i++) sixel[i] += row[i] << 1 ; break ; case 2 : for (i = 0 ; i < width ; i++) sixel[i] += row[i] << 2 ; break ; case 3 : for (i = 0 ; i < width ; i++) sixel[i] += row[i] << 3 ; break ; case 4 : for (i = 0 ; i < width ; i++) sixel[i] += row[i] << 4 ; break ; case 5 : for (i = 0 ; i < width ; i++) sixel[i] += (row[i] << 5) + 077 ; output_sixel_record (sixel, width) ; break ; } if (sixel_row == 5) sixel_row = 0 ; else sixel_row++ ; } if (sixel_row > 0) { /* Incomplete sixel record needs to be output */ for (i = 0 ; i < width ; i++) sixel[i] += 077 ; output_sixel_record (sixel, width) ; } } void main (argc, argv) int argc ; char **argv ; { int argc_copy = argc ; char **argv_copy = argv ; int argn; char *usage = "[-left ] [-right ] [-top ] [-bottom ] [-formlength ] [pbmfile]"; /* Options */ /* These defaults are for a DEC LN03 with A4 paper (2400x3400 pixels) */ char *opt_left_margin = "0"; char *opt_top_margin = opt_left_margin; char *opt_right_margin = "2400"; char *opt_bottom_margin = "3400"; char *opt_form_length = opt_bottom_margin; int width, height, format ; pbm_init (&argc_copy, argv_copy) ; argn = 1; while( argn < argc && argv[argn][0] == '-' && argv[argn][1] != '\0' ) { if( pm_keymatch(argv[argn], "-left", 2) ) { if( ++argn >= argc ) pm_usage(usage); opt_left_margin = argv[argn]; } else if( pm_keymatch(argv[argn], "-right", 2) ) { if( ++argn >= argc ) pm_usage(usage); opt_right_margin = argv[argn]; } else if( pm_keymatch(argv[argn], "-top", 2) ) { if( ++argn >= argc ) pm_usage(usage); opt_top_margin = argv[argn]; } else if( pm_keymatch(argv[argn], "-bottom", 2) ) { if( ++argn >= argc ) pm_usage(usage); opt_bottom_margin = argv[argn]; } else if( pm_keymatch(argv[argn], "-formlength", 2) ) { if( ++argn >= argc ) pm_usage(usage); opt_form_length = argv[argn]; } else pm_usage(usage); ++argn; } if( argn < argc ) { input = pm_openr( argv[argn] ); argn++; } else input = stdin; if( argn != argc ) pm_usage(usage); /* Initialise pbm file */ pbm_readpbminit (input, &width, &height, &format) ; if (format != PBM_FORMAT && format != RPBM_FORMAT) pm_error ("input not in PBM format") ; /* * In explanation of the sequence below: * [!p DECSTR soft terminal reset * [11h PUM select unit of measurement * [7 I SSU select pixel as size unit * [?52l DECOPM origin is corner of printable area * [%s;%ss DECSLRM left and right margins * [%s;%sr DECSTBM top and bottom margins * [%st DECSLPP form length * P0;0;1q select sixel graphics mode * "1;1 DECGRA aspect ratio (1:1) */ /* Initialise sixel file */ printf ( "\033[!p\033[11h\033[7 I\033[?52l\033[%s;%ss\033[%s;%sr\033[%st\033P0;0;1q\"1;1", opt_left_margin, opt_right_margin, opt_top_margin, opt_bottom_margin, opt_form_length); /* Convert data */ convert (width, height, format) ; /* Terminate sixel data */ print ("\033\\\n") ; } netpbm-8.2/pbm/Makefile.mms0100660000076400000000000002267005465675333014726 0ustar bryanhroot# MMS Description file for pbm tools. # # Copyright (C) 1989 by Jef Poskanzer. # # Permission to use, copy, modify, and distribute this software and its # documentation for any purpose and without fee is hereby granted, provided # that the above copyright notice appear in all copies and that both that # copyright notice and this permission notice appear in supporting # documentation. This software is provided "as is" without express or # implied warranty. # # Written by Rick Dyson (dyson@iowasp.physics.uiowa.edu) 10-NOV-1991 # originally based on one by Terry Poot (tp@mccall.com) # # Last Updated: 2-SEP-1993 by Rick Dyson # 16-SEP-1993 by Rick Dyson for netpbm release/Alpha03 # Default values INSTALLBINARIES = PBMplus_Root:[Exe] INSTALLMANUALS = PBMplus_Root:[TeX] PBMLIB = libpbm.olb LIBS = $(PBMLIB)/Library OPT = PBMplusSHR/Option CFLAGS = $(CFLAGS) /Define = (PBMPLUS_RAWBITS,LIBTIFF) /Include_Directory = [-] BINARIES = atktopbm.exe brushtopbm.exe cmuwmtopbm.exe g3topbm.exe \ gemtopbm.exe icontopbm.exe macptopbm.exe mgrtopbm.exe \ pbmlife.exe pbmmake.exe pbmmask.exe pbmreduce.exe \ pbmtext.exe \ pbmto10x.exe pbmto4425.exe pbmtoascii.exe pbmtoatk.exe \ pbmtobbnbg.exe pbmtocmuwm.exe pbmtoepson.exe pbmtog3.exe \ pbmtogem.exe pbmtogo.exe pbmtoicon.exe pbmtolj.exe \ pbmtomacp.exe pbmtomgr.exe pbmtopi3.exe pbmtoplot.exe \ pbmtoptx.exe pbmtox10bm.exe pbmtoxbm.exe pbmtoybm.exe \ pbmtozinc.exe pbmupc.exe pi3topbm.exe xbmtopbm.exe ybmtopbm.exe pbmtoln03.exe \ pbmclean.exe pbmpscale.exe pbmtoepsi.exe pbmtolps.exe pbmtopk.exe pktopbm.exe MANUALS1 = atktopbm.tex brushtopbm.tex cmuwmtopbm.tex g3topbm.tex \ gemtopbm.tex icontopbm.tex macptopbm.tex mgrtopbm.tex \ pbmlife.tex pbmmake.tex pbmmask.tex pbmreduce.tex \ pbmtext.tex \ pbmto10x.tex pbmto4425.tex pbmtoascii.tex pbmtoatk.tex \ pbmtobbnbg.tex pbmtocmuwm.tex pbmtoepson.tex pbmtog3.tex \ pbmtogem.tex pbmtogo.tex pbmtoicon.tex pbmtolj.tex \ pbmtomacp.tex pbmtomgr.tex pbmtopi3.tex pbmtoplot.tex \ pbmtoptx.tex pbmtox10bm.tex pbmtoxbm.tex pbmtoybm.tex \ pbmtozinc.tex pbmupc.tex pi3topbm.tex xbmtopbm.tex ybmtopbm.tex pbmtoln03.tex \ pbmclean.tex pbmpscale.tex pbmtoepsi.tex pbmtolps.tex pbmtopk.tex pktopbm.tex MANUALS3 = libpbm.tex MANUALS5 = pbm.tex MANUALS = $(MANUALS1) $(MANUALS3) $(MANUALS5) .suffixes : .tex .1 .3 .5 .first @ PBMPLUS_PATH = F$Element (0, "]", F$Environment ("DEFAULT")) - ".PBM" + ".]" @ If F$TrnLnm ("PBMplus_Root") .eqs. "" Then - Define /Translation_Attributes = Concealed PBMplus_Root "''PBMPLUS_PATH'" @ If F$TrnLnm ("PBMplus_Dir") .eqs. "" Then - Define PBMplus_Dir PBMplus_Root:[000000] @ If F$TrnLnm ("Sys") .eqs. "" Then Define Sys Sys$Library all : binaries @ Continue install : installbinaries @ Continue binaries : $(PBMLIB) $(BINARIES) @ Set Protection = (System:RWE, Owner:RWE, Group:RE, World:RE) *.exe installbinaries : $(BINARIES) @- Set Protection = (System:RWE, Owner:RWED, Group:RE, World:RE) *.exe @- Rename /Log *.exe $(INSTALLBINARIES) @- Set Protection = Owner:RWE PBMplus_Root:[Exe]*.exe manual : TeX $(MANUALS) @ Set Protection = (System:RWE, Owner:RWE, Group:RE, World:RE) *.tex installmanual : @- Set Protection = (System:RWE, Owner:RWED, Group:RE, World:RE) *.tex @- Rename *.tex $(INSTALLMANUALS) @- Set Protection = Owner:RWE PBMplus_Root:[TeX]*.tex TeX : SETUP TeX # Rules for creating TeX documentation from troff files. .1.tex : tr2TeX -m -t -o $*.tex $*.1 .3.tex : tr2TeX -m -t -o $*.tex $*.3 .5.tex : tr2TeX -m -t -o $*.tex $*.5 # Rule for plain programs. .obj.exe : $(LINK) $(LINKFLAGS) $*.obj,$(OPT) # $(LINK) $(LINKFLAGS) $*.obj,$(LIBS)/Library,$(OPT) # And libraries. lib : $(PBMLIB) @ Continue $(PBMLIB) : libpbm1.obj libpbm2.obj libpbm3.obj libpbm4.obj libpbm5.obj Library /Create $(PBMLIB) libpbm%.obj libpbm1.obj : libpbm1.c pbm.h [-]pbmplus.h libpbm.h [-]version.h includes.h libpbm2.obj : libpbm2.c pbm.h [-]pbmplus.h libpbm.h libpbm3.obj : libpbm3.c pbm.h [-]pbmplus.h libpbm.h libpbm4.obj : libpbm4.c pbm.h [-]pbmplus.h libpbm.h libpbm5.obj : libpbm5.c pbm.h [-]pbmplus.h # Object file dependencies atktopbm.obj : atktopbm.c pbm.h [-]pbmplus.h brushtopbm.obj : brushtopbm.c pbm.h [-]pbmplus.h cmuwmtopbm.obj : cmuwmtopbm.c cmuwm.h pbm.h [-]pbmplus.h g3topbm.obj : g3topbm.c g3.h pbm.h [-]pbmplus.h gemtopbm.obj : gemtopbm.c pbm.h [-]pbmplus.h icontopbm.obj : icontopbm.c pbm.h [-]pbmplus.h macptopbm.obj : macptopbm.c macp.h pbm.h [-]pbmplus.h mgrtopbm.obj : mgrtopbm.c mgr.h pbm.h [-]pbmplus.h pbmlife.obj : pbmlife.c pbm.h [-]pbmplus.h pbmmake.obj : pbmmake.c pbm.h [-]pbmplus.h pbmmask.obj : pbmmask.c pbm.h [-]pbmplus.h pbmreduce.obj : pbmreduce.c pbm.h [-]pbmplus.h pbmtext.obj : pbmtext.c pbm.h pbmfont.h [-]pbmplus.h pbmto10x.obj : pbmto10x.c pbm.h [-]pbmplus.h pbmto4425.obj : pbmto4425.c pbm.h [-]pbmplus.h pbmtoascii.obj : pbmtoascii.c pbm.h [-]pbmplus.h pbmtoatk.obj : pbmtoatk.c pbm.h [-]pbmplus.h pbmtobbnbg.obj : pbmtobbnbg.c pbm.h [-]pbmplus.h pbmtocmuwm.obj : pbmtocmuwm.c cmuwm.h pbm.h [-]pbmplus.h pbmtoepson.obj : pbmtoepson.c pbm.h [-]pbmplus.h pbmtog3.obj : pbmtog3.c g3.h pbm.h [-]pbmplus.h pbmtogem.obj : pbmtogem.c pbm.h [-]pbmplus.h pbmtogo.obj : pbmtogo.c pbm.h [-]pbmplus.h pbmtoicon.obj : pbmtoicon.c pbm.h [-]pbmplus.h pbmtolj.obj : pbmtolj.c pbm.h [-]pbmplus.h pbmtomacp.obj : pbmtomacp.c macp.h pbm.h [-]pbmplus.h pbmtomgr.obj : pbmtomgr.c mgr.h pbm.h [-]pbmplus.h pbmtopi3.obj : pbmtopi3.c pbm.h [-]pbmplus.h pbmtoplot.obj : pbmtoplot.c pbm.h [-]pbmplus.h pbmtoptx.obj : pbmtoptx.c pbm.h [-]pbmplus.h pbmtox10bm.obj : pbmtox10bm.c pbm.h [-]pbmplus.h pbmtoxbm.obj : pbmtoxbm.c pbm.h [-]pbmplus.h pbmtoybm.obj : pbmtoybm.c pbm.h [-]pbmplus.h pbmtozinc.obj : pbmtozinc.c pbm.h [-]pbmplus.h pbmupc.obj : pbmupc.c pbm.h [-]pbmplus.h pi3topbm.obj : pi3topbm.c pbm.h [-]pbmplus.h xbmtopbm.obj : xbmtopbm.c pbm.h [-]pbmplus.h ybmtopbm.obj : ybmtopbm.c pbm.h [-]pbmplus.h pbmtoln03.obj : pbmtoln03.c pbm.h [-]pbmplus.h pbmclean.obj : pbmclean.c pbm.h [-]pbmplus.h pbmpscale.obj : pbmpscale.c pbm.h [-]pbmplus.h pbmtoepsi.obj : pbmtoepsi.c pbm.h [-]pbmplus.h pbmtolps.obj : pbmtolps.c pbm.h [-]pbmplus.h pbmtopk.obj : pbmtopk.c pbm.h [-]pbmplus.h pktopbm.obj : pktopbm.c pbm.h [-]pbmplus.h # Binary dependencies, someone may want to build just a single image atktopbm.exe : atktopbm.obj $(PBMLIB) brushtopbm.exe : brushtopbm.obj $(PBMLIB) cmuwmtopbm.exe : cmuwmtopbm.obj $(PBMLIB) g3topbm.exe : g3topbm.obj $(PBMLIB) gemtopbm.exe : gemtopbm.obj $(PBMLIB) icontopbm.exe : icontopbm.obj $(PBMLIB) macptopbm.exe : macptopbm.obj $(PBMLIB) mgrtopbm.exe : mgrtopbm.obj $(PBMLIB) pbmlife.exe : pbmlife.obj $(PBMLIB) pbmmake.exe : pbmmake.obj $(PBMLIB) pbmmask.exe : pbmmask.obj $(PBMLIB) pbmreduce.exe : pbmreduce.obj $(PBMLIB) pbmtext.exe : pbmtext.obj $(PBMLIB) pbmto10x.exe : pbmto10x.obj $(PBMLIB) pbmtoascii.exe : pbmtoascii.obj $(PBMLIB) pbmtoatk.exe : pbmtoatk.obj $(PBMLIB) pbmtobbnbg.exe : pbmtobbnbg.obj $(PBMLIB) pbmtocmuwm.exe : pbmtocmuwm.obj $(PBMLIB) pbmtoepson.exe : pbmtoepson.obj $(PBMLIB) pbmtog3.exe : pbmtog3.obj $(PBMLIB) pbmtogem.exe : pbmtogem.obj $(PBMLIB) pbmtogo.exe : pbmtogo.obj $(PBMLIB) pbmtoicon.exe : pbmtoicon.obj $(PBMLIB) pbmtolj.exe : pbmtolj.obj $(PBMLIB) pbmtomacp.exe : pbmtomacp.obj $(PBMLIB) pbmtomgr.exe : pbmtomgr.obj $(PBMLIB) pbmtopi3.exe : pbmtopi3.obj $(PBMLIB) pbmtoplot.exe : pbmtoplot.obj $(PBMLIB) pbmtoptx.exe : pbmtoptx.obj $(PBMLIB) pbmtox10bm.exe : pbmtox10bm.obj $(PBMLIB) pbmtoxbm.exe : pbmtoxbm.obj $(PBMLIB) pbmtoybm.exe : pbmtoybm.obj $(PBMLIB) pbmtozinc.exe : pbmtozinc.obj $(PBMLIB) pbmupc.exe : pbmupc.obj $(PBMLIB) pi3topbm.exe : pi3topbm.obj $(PBMLIB) xbmtopbm.exe : xbmtopbm.obj $(PBMLIB) ybmtopbm.exe : ybmtopbm.obj $(PBMLIB) pbmtoln03.exe : pbmtoln03.obj $(PBMLIB) pbmclean.exe : pbmclean.obj $(PBMLIB) pbmpscale.exe : pbmpscale.obj $(PBMLIB) pbmtoepsi.exe : pbmtoepsi.obj $(PBMLIB) pbmtolps.exe : pbmtolps.obj $(PBMLIB) pbmtopk.exe : pbmtopk.obj $(PBMLIB) pktopbm.exe : pktopbm.obj $(PBMLIB) # TeX documentation dependencies atktopbm.tex : atktopbm.1 brushtopbm.tex : brushtopbm.1 cmuwmtopbm.tex : cmuwmtopbm.1 g3topbm.tex : g3topbm.1 gemtopbm.tex : gemtopbm.1 icontopbm.tex : icontopbm.1 macptopbm.tex : macptopbm.1 mgrtopbm.tex : mgrtopbm.1 pbmlife.tex : pbmlife.1 pbmmake.tex : pbmmake.1 pbmmask.tex : pbmmask.1 pbmreduce.tex : pbmreduce.1 pbmtext.tex : pbmtext.1 pbmto10x.tex : pbmto10x.1 pbmtoascii.tex : pbmtoascii.1 pbmtoatk.tex : pbmtoatk.1 pbmtobbnbg.tex : pbmtobbnbg.1 pbmtocmuwm.tex : pbmtocmuwm.1 pbmtoepson.tex : pbmtoepson.1 pbmtog3.tex : pbmtog3.1 pbmtogem.tex : pbmtogem.1 pbmtogo.tex : pbmtogo.1 pbmtoicon.tex : pbmtoicon.1 pbmtolj.tex : pbmtolj.1 pbmtomacp.tex : pbmtomacp.1 pbmtomgr.tex : pbmtomgr.1 pbmtopi3.tex : pbmtopi3.1 pbmtoplot.tex : pbmtoplot.1 pbmtoptx.tex : pbmtoptx.1 pbmtox10bm.tex : pbmtox10bm.1 pbmtoxbm.tex : pbmtoxbm.1 pbmtoybm.tex : pbmtoybm.1 pbmtozinc.tex : pbmtozinc.1 pbmupc.tex : pbmupc.1 pi3topbm.tex : pi3topbm.1 xbmtopbm.tex : xbmtopbm.1 ybmtopbm.tex : ybmtopbm.1 pbmtoln03.tex : pbmtoln03.1 pbmclean.tex : pbmclean.1 pbmpscale.tex : pbmpscale.1 pbmtoepsi.tex : pbmtoepsi.1 pbmtolps.tex : pbmtolps.1 pbmtopk.tex : pbmtopk.1 pktopbm.tex : pktopbm.1 clean : - Set Protection = Owner:RWED *.obj;*,*.*;-1 - Purge /NoLog /NoConfirm *.* - Delete /NoLog /NoConfirm *.obj; netpbm-8.2/pbm/libpbm5.c0100660000076400000000000013052607065037241014155 0ustar bryanhroot/* libpbm5.c - pbm utility library part 5 ** ** Font routines. ** ** Support for BDF fonts Copyright 1993 by George Phillips. ** ** Copyright (C) 1991 by Jef Poskanzer. ** ** Permission to use, copy, modify, and distribute this software and its ** documentation for any purpose and without fee is hereby granted, provided ** that the above copyright notice appear in all copies and that both that ** copyright notice and this permission notice appear in supporting ** documentation. This software is provided "as is" without express or ** implied warranty. */ #include #include "pbm.h" #include "pbmfont.h" /* The default font, packed in hex so this source file doesn't get huge. ** You can replace this with your own font using pbm_dumpfont(). */ #define DEFAULTFONT_ROWS 155 #define DEFAULTFONT_COLS 112 static unsigned long defaultfont_bits[DEFAULTFONT_ROWS][(DEFAULTFONT_COLS+31)/32] = { {0x00000000L,0x20000c00L,0x10000000L,0x00000000L}, {0xc600a000L,0x42000810L,0x00000002L,0x00000063L}, {0x6c00a000L,0x45000810L,0x00000002L,0x00000036L}, {0x6c00a000L,0x88800808L,0xf2e1dee2L,0x00000036L}, {0x54000000L,0x80000800L,0x11122442L,0x0000002aL}, {0x54000001L,0x00000800L,0x11122442L,0x0000002aL}, {0x54000001L,0x00000800L,0x11122282L,0x0000002aL}, {0x44000102L,0x00000800L,0x11122382L,0x00000022L}, {0xee000102L,0x00000800L,0x11e1e102L,0x00000077L}, {0x00000204L,0x00000800L,0x11002102L,0x00000000L}, {0x00000000L,0x00000c00L,0x11002102L,0x00000000L}, {0x00000000L,0x003f8000L,0xe3807600L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x02000080L,0x00040000L,0x00120000L,0x00000001L}, {0x04000082L,0x828e1838L,0x20210100L,0x00000002L}, {0x04000082L,0x82912448L,0x20210100L,0x00000002L}, {0x08000082L,0x8fd01940L,0x404087c2L,0x00000004L}, {0x08000080L,0x050c0622L,0x00408102L,0x00000004L}, {0x10000080L,0x05061874L,0x0040828fL,0x00008008L}, {0x10000080L,0x1f912688L,0x00408002L,0x00000008L}, {0x20000000L,0x0a11098cL,0x00408002L,0x00000010L}, {0x20000080L,0x0a0e0672L,0x00210000L,0x00000010L}, {0x40000000L,0x00040000L,0x00210000L,0x00000020L}, {0x00000000L,0x00000000L,0x00120000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00000000L,0x004e0838L,0x7023e1cfL,0x00008000L}, {0x00000000L,0x00913844L,0x88620208L,0x00008000L}, {0x08000000L,0x00910844L,0x08a20401L,0x00000004L}, {0x10000000L,0x01110844L,0x08a20401L,0x00000008L}, {0x20000000L,0x01110808L,0x3123c781L,0x00000010L}, {0x400003e0L,0x02110810L,0x0a202441L,0x00000020L}, {0x20000000L,0x02110820L,0x0bf02442L,0x00000010L}, {0x10008000L,0x04110844L,0x88242442L,0x00000008L}, {0x08008002L,0x040e3e7cL,0x7073c382L,0x00000004L}, {0x00010000L,0x08000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x0000e1c0L,0x00000000L,0x00000000L,0x00000000L}, {0x00011220L,0x00000000L,0x70e38f87L,0x00000000L}, {0x20011220L,0x00020020L,0x89108448L,0x00008010L}, {0x10011220L,0x00040010L,0x09314448L,0x00008008L}, {0x0800e221L,0x02083e08L,0x11514788L,0x00000004L}, {0x040111e0L,0x00100004L,0x2153e448L,0x00000002L}, {0x08011020L,0x00083e08L,0x213a2448L,0x00008004L}, {0x10011040L,0x02040010L,0x01022448L,0x00008008L}, {0x2000e381L,0x02020020L,0x20e77f87L,0x00000010L}, {0x00000000L,0x04000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x3803e7efL,0xc73bbe3dL,0xdb863ce7L,0x0000001cL}, {0x44011224L,0x48910808L,0x91036648L,0x00008022L}, {0x4c011285L,0x48910808L,0xa1036648L,0x00008026L}, {0x54011387L,0x081f0808L,0xc102a548L,0x0000802aL}, {0x54011285L,0x09910808L,0xe102a548L,0x0000802aL}, {0x4e011204L,0x08910848L,0x9112a4c8L,0x00008027L}, {0x40011224L,0x08910848L,0x891224c8L,0x00008020L}, {0x3803e7efL,0x073bbe31L,0xcff77e47L,0x0000001cL}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00000000L,0x00000000L,0x00000003L,0x00000000L}, {0x0003e1cfL,0x87bff7efL,0xdfbf77c2L,0x00000000L}, {0x00013224L,0x48a4a244L,0x89122442L,0x00000000L}, {0x00011224L,0x4824a244L,0xa8a14482L,0x00000000L}, {0x00013227L,0x8e04226cL,0xa8414102L,0x00000000L}, {0x0001e224L,0x83842228L,0xa8a08102L,0x00000000L}, {0x00010224L,0x40842228L,0xd8a08242L,0x00000000L}, {0x00010224L,0x48843638L,0x51108442L,0x00000000L}, {0x0003c1ceL,0x6f1f1c10L,0x53b9c7c2L,0x00000000L}, {0x00000060L,0x00000000L,0x00000002L,0x00000000L}, {0x00000000L,0x00000000L,0x00000003L,0x00000000L}, {0xfe000000L,0x00000000L,0x00000000L,0x0000007fL}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00010180L,0x000000c0L,0x003001c0L,0x00000000L}, {0x08008081L,0x00040040L,0x00100200L,0x00000004L}, {0x10008082L,0x80040040L,0x00100200L,0x00000008L}, {0x10004084L,0x40023c78L,0x70f1c7c7L,0x00004008L}, {0x10004080L,0x00000244L,0x89122208L,0x00008008L}, {0x20002080L,0x00001e44L,0x8113e208L,0x00008010L}, {0x10002080L,0x00002244L,0x81120208L,0x00008008L}, {0x10001080L,0x00002244L,0x89122208L,0x00008008L}, {0x10001080L,0x00001db8L,0x70e9c787L,0x00008008L}, {0x10000880L,0x00000000L,0x00000000L,0x00008008L}, {0x08000180L,0x00000000L,0x00000000L,0x00008004L}, {0x00000000L,0x1fc00000L,0x00000007L,0x00000000L}, {0x00000000L,0x00000000L,0x00000000L,0x00000000L}, {0x00030080L,0x981c0000L,0