raven/jedioutcast
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
jedioutcast/utils/roq2/libim/impcx.c

3194 lines
53 KiB
C
Raw Normal View History

Jedi Outcast v056
2013-04-04 18:02:27 +00:00
/**
** $Header: /roq/libim/impcx.c 1 11/02/99 4:38p Zaphod $
** Copyright (c) 1989-1995 San Diego Supercomputer Center (SDSC)
** a division of General Atomics, San Diego, California, USA
**
** Users and possessors of this source code are hereby granted a
** nonexclusive, royalty-free copyright and design patent license to
** use this code in individual software. License is not granted for
** commercial resale, in whole or in part, without prior written
** permission from SDSC. This source is provided "AS IS" without express
** or implied warranty of any kind.
**
** For further information contact:
** E-Mail: info@sds.sdsc.edu
**
** Surface Mail: Information Center
** San Diego Supercomputer Center
** P.O. Box 85608
** San Diego, CA 92138-5608
** (619) 534-5000
**/
#define HEADER " $Header: /roq/libim/impcx.c 1 11/02/99 4:38p Zaphod $"
/**
** FILE
** impcx.c - ZSoft IBM PC Paintbrush image file I/O
**
** PROJECT
** libim - SDSC image manipulation library
**
** DESCRIPTION
** impcx.c contains routines to read and write ZSoft PCX files for
** the image manipulation library. Raster data read in is stored
** in a VFB. Raster data written out is taken from a tag table.
**
** PUBLIC CONTENTS
** d =defined constant
** f =function
** m =defined macro
** t =typedef/struct/union
** v =variable
** ? =other
**
** imPcxRead f read an PCX file
** imPcxWrite1 f write a 1-bit PCX file
** imPcxWrite8 f write an 8-bit PCX file
**
** PRIVATE CONTENTS
** imPcxHeaderInfo t header for PCX files
** imPcxHeaderFields v header description for binary I/O package
**
** HISTORY
** $Log: /roq/libim/impcx.c $
*
* 1 11/02/99 4:38p Zaphod
** Revision 1.12 1995/06/29 00:28:04 bduggan
** updated copyright year
**
** Revision 1.11 1995/06/15 20:48:58 bduggan
** Removed useless ++. Changed bzero to memset.
**
** Revision 1.10 1995/04/03 21:32:34 bduggan
** took out #ifdef NEWMAGIC
**
** Revision 1.9 1995/01/10 23:36:33 bduggan
** put in IMMULTI, IMPIPE instead of TRUE/FALSE
** uncapitlized i's in local functions
** made read/write routines static
**
** Revision 1.8 94/10/03 11:30:21 nadeau
** Updated to ANSI C and C++ compatibility.
** Removed all use of register keyword.
** Minimized use of custom SDSC types (e.g., uchar vs. unsigned char)
** Changed all float arguments to double.
** Added forward declarations.
** Added misc. casts to passify SGI and DEC compilers.
** Changed all macros and defined constants to have names
** starting with IM.
** Rearranged magic number structures for format handlers.
** Made format handler routines static (i.e., local to file).
** Updated comments, adding format descriptions and references.
** Updated indenting on some code.
** Updated copyright message.
**
** Revision 1.7 92/12/03 01:50:23 nadeau
** Corrected info messages.
**
** Revision 1.6 92/11/23 18:42:43 nadeau
** Removed use of IMINFOMSG.
**
** Revision 1.5 92/11/04 12:12:37 groening
** put ImFIleFormat info and magic number info
** from imfmt.c into this file.
**
** Revision 1.4 92/09/29 18:00:29 vle
** Added ImInfo messages.
**
** Revision 1.3 92/08/31 17:30:11 vle
** Updated copyright notice.
**
** Revision 1.2 91/10/03 09:15:18 nadeau
** Added undocumented PC PaintBrush CLT type.
**
** Revision 1.1 91/09/17 20:16:28 nadeau
** Initial revision
**
**/
#include "iminternal.h"
/**
** $Header: /roq/libim/impcx.c 1 11/02/99 4:38p Zaphod $
** Copyright (c) 1989-1994 San Diego Supercomputer Center (SDSC)
** a division of General Atomics, San Diego, California, USA
**
** Users and possessors of this source code are hereby granted a
** nonexclusive, royalty-free copyright and design patent license to
** use this code in individual software. License is not granted for
** commercial resale, in whole or in part, without prior written
** permission from SDSC. This source is provided "AS IS" without express
** or implied warranty of any kind.
**
** For further information contact:
** E-Mail: info@sds.sdsc.edu
**
** Surface Mail: Information Center
** San Diego Supercomputer Center
** P.O. Box 85608
** San Diego, CA 92138-5608
** (619) 534-5000
**/
#define HEADER " $Header: /roq/libim/impcx.c 1 11/02/99 4:38p Zaphod $"
/**
** FILE
** impcx.c - ZSoft IBM PC Paintbrush image file I/O
**
** PROJECT
** libim - SDSC image manipulation library
**
** DESCRIPTION
** impcx.c contains routines to read and write ZSoft PCX files for
** the image manipulation library. Raster data read in is stored
** in a VFB. Raster data written out is taken from a tag table.
**
** PUBLIC CONTENTS
** d =defined constant
** f =function
** m =defined macro
** t =typedef/struct/union
** v =variable
** ? =other
**
** done
**
** PRIVATE CONTENTS
** imPcxRead f read an PCX file
** imPcxWrite1 f write a 1-bit PCX file
** imPcxWrite8 f write an 8-bit PCX file
** imPcxHeaderInfo t header for PCX files
** imPcxHeaderFields v header description for binary I/O package
**
** HISTORY
** $Log: /roq/libim/impcx.c $
*
* 1 11/02/99 4:38p Zaphod
** Revision 1.12 1995/06/29 00:28:04 bduggan
** updated copyright year
**
** Revision 1.11 1995/06/15 20:48:58 bduggan
** Removed useless ++. Changed bzero to memset.
**
** Revision 1.10 1995/04/03 21:32:34 bduggan
** took out #ifdef NEWMAGIC
**
** Revision 1.9 1995/01/10 23:36:33 bduggan
** put in IMMULTI, IMPIPE instead of TRUE/FALSE
** uncapitlized i's in local functions
** made read/write routines static
**
** Revision 1.8 94/10/03 11:30:21 nadeau
** Updated to ANSI C and C++ compatibility.
** Removed all use of register keyword.
** Minimized use of custom SDSC types (e.g., uchar vs. unsigned char)
** Changed all float arguments to double.
** Added forward declarations.
** Added misc. casts to passify SGI and DEC compilers.
** Changed all macros and defined constants to have names
** starting with IM.
** Rearranged magic number structures for format handlers.
** Made format handler routines static (i.e., local to file).
** Updated comments, adding format descriptions and references.
** Updated indenting on some code.
** Updated copyright message.
**
** Revision 1.7 92/12/03 01:50:23 nadeau
** Corrected info messages.
**
** Revision 1.6 92/11/23 18:42:43 nadeau
** Removed use of IMINFOMSG.
**
** Revision 1.5 92/11/04 12:12:37 groening
** put ImFIleFormat info and magic number info
** from imfmt.c into this file.
**
** Revision 1.4 92/09/29 18:00:29 vle
** Added ImInfo messages.
**
** Revision 1.3 92/08/31 17:30:11 vle
** Updated copyright notice.
**
** Revision 1.2 91/10/03 09:15:18 nadeau
** Added undocumented PC PaintBrush CLT type.
**
** Revision 1.1 91/09/17 20:16:28 nadeau
** Initial revision
**
**/
#include "iminternal.h"
/**
** FORMAT
** PCX - ZSoft IBM PC Paintbrush image
**
** AKA
** pcc
**
** FORMAT REFERENCES
** - Technical Reference Manual for PC Paintbrush et al, ZSoft Corp.
** - Bit-Mapped Graphics, Steve Rimmer
** - Supercharged Bitmapped Graphics, Steve Rimmer
** - Graphics File Formats, David C. Kay, John R. Levine
** - HP LaserJet Programming, Andrew Binstock, David Babcock, Marv Luse
**
** CODE CREDITS
** Custom development, Dave Nadeau, San Diego Supercomputer Center, 1991.
**
** DESCRIPTION
** ZSoft's PCX format is used by a variety of IBM PC software, including
** ZSoft's own Publisher's Paintbrush, PC Paintbrush Plus, and PC
** Paintbrush.
**
** This code supports the format as described in:
**
** Technical Reference Manual
** ZSoft Corporation
** 450 Franklin Rd. Suite 100
** Marietta, GA 30067
** (404) 428-0008
**
** This report is dated 1988.
**
** Additional format information was obtained from the book "Bit-Mapped
** Graphics" by Steve Rimmer and published by WINDCREST/McGraw-Hill.
**
** PCX files start with a fixed-length 128-byte header consisting of
** the following:
**
** Byte Item Size Description/Comments
**
** 0 Manufacturer 1 10 = ZSoft .PCX
**
** 1 Version 1 Version #
** 0 = Version 2.5
** 2 = Version 2.8 w/palette info
** 3 = Version 2.8 wo/palette info
** 5 = Version 3.0
**
** 2 Encoding 1 1 = .PCX run length encoding
**
** 3 Bits per pixel 1 # of bits/pixel per plane
** 1 = monochrome (CGA)
** 4 = 16-color (EGA)
** 8 = 256-color (VGA)
**
** 4 Window 4*2 Picture dimensions
** xmin
** ymin
** xmax
** ymax
**
** 12 Horizontal Res 2 Horizontal resolution of dev, in pixels
**
** 14 Vertical Res 2 Vertical resolution of dev, in pixels
**
** 16 Colormap 16*3 Basic color table
**
** 64 Reserved 1
**
** 65 No. Planes 1 # of color planes
**
** 66 Bytes per line 2 # of bytes per scanline per color
** color plane (always even)
**
** 68 Colormap type 2 Colormap type
** 1 = color/BW
** 2 = grayscale
**
** 70 Filler 58 Blanks
**
** All 2-byte integers are given in Intel byte order (LBF).
**
** Image data immediately follows the header. In version 6.0 PCX files,
** an optional 256-entry color palette may follow the image data (but
** see below).
**
** HEADER DETAILS
** The 'Manufacturer' field is always '10' for PCX files. ZSoft has never
** introduced further 'Manufacturer' codes. The SDSC Image Tools use
** the 'Manufacturer' field as the file's magic number.
**
** The 'Encoding' field is always '1'. ZSoft has never introduced other
** encoding schemes (which it should have, since this one is particularly
** stupid). ZSoft does not support unencoded images in PCX files.
**
** The 'Window' field is used to compute the image dimensions using:
**
** width = xmax - xmin + 1;
** height = ymax - ymin + 1;
**
** Note the '+1' needed on both of these. Just a quirk of PCX files.
** On write, the SDSC Image Tools set the 'xmin' and 'ymin' fields to 0,
** and the 'xmax' and 'ymax' fields to the width and height, minus 1.
**
** The 'Horizontal Res' and 'Vertical Res' fields are irrelevant.
** SDSC Image Tools code ignores these on read, and sets them to 0's
** on write.
**
** NOTE: The popular UNIX PBM+ tools set the horizontal and
** vertical device resolution to the image size on write, but
** ignore them on read. This is incorrect. The resolution fields
** are defined by the spec to be HARDWARE resolution, not image
** resolution. We feel that setting them to zeroes is less
** incorrect than setting them to some value.
**
** The 'Reserved' and 'Filler' fields are always ignored by us on
** read, and always set to 0's on write.
**
** The remaining fields have specific combinations of values depending
** upon the type of image being stored.
**
** MONOCHROME IMAGES
** Monochrome PCX files were intended for the original CGA card as well
** as single-plane use of the EGA card.
**
** Header values set to the following flag monochrome images:
**
** Version = 0, 2, or 3
** Bits per pixel = 1
** Colormap = ignored
** No. Planes = 1
** Bytes per line = (width + 7) / 8 rounded up to even byte count
** Colormap type = ignored
**
** Image data following the header is an encoded buffer with 8 pixels
** to the byte. The left-most bit in each byte corresponds to the
** left-most pixel of each group of 8. Scanline buffers are rounded up
** to an even number of bytes, then encoded (see below).
**
** "Extra" image data may follow the last scanline in order to bring the
** image data up to a multiple of 8 or 16 scanlines. On read, we ignore
** such extra data. On write we don't write extra data.
**
** 4-BIT COLOR IMAGES
** 4-bit color PCX files were intended for the four-plane mode of the
** EGA card.
**
** Header values set to the following flag 4-bit color images:
**
** Version = 2 or 3
** Bits per pixel = 1
** Colormap = used (see below)
** No. Planes = 4
** Bytes per line = (width + 7)/8 rounded up to even byte count
** Colormap type = ignored
**
** If the 'Version' field of the header is a '2', the header contains
** a color palette in the 'Colormap' portion of the header. Palette
** values are given from low to high and consist of 16 3-byte RGB triplets.
**
** If the 'Version' field of the header is a '3', the header does not
** contain a palette for the image. For our purposes, this makes the
** image grayscale.
**
** Image data following the header is grouped as four consequetive
** 1-bit scanlines of data. Each 1-bit scanline is packed into bytes
** at 8 pixels to the byte, with the left most bit in each byte
** corresponding to the left-most pixel of each group of 8. The entire
** set of 4 1-bit scanlines is considered one buffer, and as a whole
** is padded to the next higher even byte boundary, then encoded.
**
** For encoding purposes, the group of 4 1-bit scanlines is considered
** a single buffer. Encoding always breaks at the end of such a buffer,
** but might not break going from one 1-bit scanline to the next within
** such a group.
**
** "Extra" image data may follow the last scanline in order to bring the
** image data up to a multiple of 8 or 16 scanlines. We neither read it
** or write it.
**
** 8-BIT COLOR IMAGES
** 8-bit color PCX files were intended for the VGA card.
**
** Header values set to the following flag 8-bit color images:
**
** Version = 5
** Bits per plane = 8
** Colormap = unused (see below)
** No. Planes = 1
** Bytes per line = ((width + 1)/2) * 2
** Colormap type = 1 or 2
**
** The 'Version' field will always be 5 for 8-bit color images.
**
** The color palette for 8-bit color images is too big for the 'Colormap'
** field of the header. Instead, the palette, if any, is tacked onto
** the end of the image data. The "official" procedure (from the spec)
** is to seek to 769 bytes before the end of the file and read a byte.
** If it is a 0x0C (12 decimal), then the next 768 bytes are 256 3-byte
** RGB triplets.
**
** The 'Colormap type' field is meant to toggle the VGA card between
** grayscale and color. In our case, it is meaningless. The existance
** of a palette makes the image color. Nonexistance means the image is
** grayscale. On read, we ignore this field. On write, we always set
** it to 1 (color).
**
** Image data following the header is encoded from a stream of bytes,
** at one byte per pixel. Consequetive bits in each byte correspond to
** consequetive color planes (as with normal graphics hardware).
** As with monochrome and 4-bit images, each scanline buffer is rounded
** up to an even number of bytes. Encoding breaks at the end of each
** scanline.
**
** "Extra" image data may follow the last scanline in order to bring the
** image data up to a multiple of 8 or 16 scanlines. We neither read or
** write such extra scanlines.
**
** ENCODING
** Image data buffers are encoded with a type of run-length encoding.
** A data byte with its upper two bits set is a run count for the number
** of times to repeat the next byte in the file. Data bytes without
** their upper two bits set are literal values. For example:
**
** Decode:
** pEncoded = encodedBuffer;
** pDecoded = decodedBuffer;
** pEnd = decodedBuffer + BytesPerLine;
** while ( pDecoded < pEnd )
** {
** if ( (*pEncoded & 0xC0) == 0xC0 )
** {
** count = (*pEncoded++) & 0x3F;
** value = *pEncoded++;
** for ( j = 0; j < count; j++ )
** *pDecoded++ = value;
** }
** else
** *pDecoded++ = *pEncoded++;
** }
**
** When encoding one must watch for data values with their upper two
** bits set. Such bytes are encoded as a run byte of 1 followed by
** the data byte.
**
** The worst case image only contains data bytes with their upper two
** bits set. This will cause an encoded image to take DOUBLE the space
** of the unencoded image. Brain dead.
**
** COLOR TABLE CAVEATS
** #1: PBM+ Problems.
** According to the spec, the existance and style of CLT is determined
** by the header's version number:
**
** 0 2.5 no CLT
** 2 2.8W CLT in header
** 3 2.8WO no CLT
** 5 3.0 CLT at end of file (possibly)
**
** Unfortunately, the popular PBM+ package for UNIX systems always
** generates PCX files for verison 3.0, and assumes other packages
** will check the header plane and bits per pixel fields to decide
** where a CLT is.
**
** In order to be compatible with this software, we ignore the version
** number header and similarly depend upon the plane and bits per pixel
** counts to decide what type of CLT, if any, is present. The only
** version number we check is 2.8WO which explicitly says there is no
** CLT for the image and that the header CLT should be ignored.
**
** Fortunately, this change of parsing still maintains compatibility
** with PCX usage. For CLT writing, we choose the right version number
** the way we're supposed to.
**
** #2: Spec Problems.
** The PCX spec recommends finding end-of-file CLTs by the following:
**
** lseek( fd, -769, 2 ); -- seek to end of file, -769 bytes
** read( fd, buffer, 1 ); -- read 1 byte
** if ( *buffer == 0x0C )
** there is a CLT
**
** This is not a robust way of checking for an EOF CLT. Imagine the
** case where there is no CLT, and seeking back 769 bytes gets you
** into the middle of image data. 0x0C is not a byte that is impossible
** to encounter in image data. If you happened to encounter it, you
** would mistakenly conclude there was a CLT.
**
** The popular UNIX PBM+ package simply reads the image data in, one
** byte at a time. When it has finished reading in the data, it looks
** at the next byte to see if it is 0x0C. If so, it reads in a CLT.
**
** This is neither speedy (lots of single byte reads) nor robust.
** The spec says:
** "There may be extra scan lines at the bottom of the image,
** to round to 8 or 16 scan lines."
**
** If they were there, PBM+ would not find the CLT.
**
** Our approach is more robust and much faster.
**
** The CLT is read in first by the seek approach. Doing it first is
** merely convenient algorithmically. It could be done last as well.
**
** The image data is then read in by making a worst-case guess at its
** size in bytes (twice the size of a decoded image). This will
** very likely read too much data. This is OK since we watch the
** decode count while decoding so that we don't decode off the end of
** the image. The advantage is that we can read it all in with one
** read system call. Much much much faster.
**
** After decoding, a count is returned of the number of encoded bytes
** used. To determine if the CLT we read in earlier is truely a CLT,
** and not image data improperly interpreted, we compare the file position
** of the 769-bytes-from-the-end CLT with the position we'd be at if we
** had only read in the image data (header + # of encoded bytes used).
** If the CLT file position is in advance of the end-of-image data
** position, then it is considered a valid CLT.
**
** It is still possible that there are lots and lots of "extra" scanlines
** after the image data and that they contain 0x0C's. A seek into the
** midst of these would still falsly conclude there was a CLT there.
** This seems very unlikely. Software that pads with extra scanlines
** usually sets them to zeroes.
**
** IMAGE DATA CAVEATS
** #1: Even-byte-count buffers
** According to the spec, all scanlines, prior to encoding, are rounded
** up to an even number of bytes. Unfortunately, the popular PBM+
** package for UNIX systems fails to do this.
**
** In order to be compatible with this software, we check the header's
** "Bytes per line" field and skip the difference between it and the
** size of a decoded buffer. If the PCX generator made the byte count
** even, this will skip 1 byte for odd-length lines. If the PCX generator
** did not make this even, such as PBM+, then this will skip no bytes
** in such cases.
**
** Fortunately, this change of skipping still maintains compatibility
** with PCX usage. For image writing, we round up the way we're
** supposed to.
**
** #2: 2-bit and 3-bit color images
** According to the documentation, 2-bit and 3-bit images aren't really
** allowed. However, the poplular UNIX PBM+ package freely generates
** them.
**
** In order to be compatible with such code, we also accept 2-bit and
** 3-bit images as variations of the 4-bit case.
**
** Header values set to the following flag 4-bit color images:
**
** Version = 2 or 3
** Bits per pixel = 1
** Colormap = used (see below)
** No. Planes = 2 or 3
** Bytes per line = (width + 7)/8 rounded up to even byte count
** Colormap type = ignored
**
** 2-bit and 3-bit cases are stored the same as for the 4-bit case.
*/
/*
* PCX - ZSoft IBM PC Paintbrush
* For information on these structures, how to use them, etc. please
* see imfmt.c.
*/
#ifdef __STDC__
static int imPcxRead( int ioType, int fd, FILE *fp, TagTable *flagsTable, TagTable *tagTable );
static int imPcxWrite1( ImFileFormatWriteMap *pMap, int ioType, int fd, FILE *fp, TagTable *flagsTable, TagTable *tagTable );
static int imPcxWrite8( ImFileFormatWriteMap *pMap, int ioType, int fd, FILE *fp, TagTable *flagsTable, TagTable *tagTable );
#else
static int imPcxRead( );
static int imPcxWrite1( ), imPcxWrite8( );
#endif
static char *imPcxNames[ ] = { "pcx", "pcc", NULL };
static unsigned char imPcxMagicNumber[ ] = { 0x0a };
static ImFileFormatReadMap imPcxReadMap[ ] =
{
/* in out */
/* type,ch,dep, attr. VFB type attr. */
{ IN,1,1, RLE, IMVFBMONO, 0 },
{ IN,1,2, RLE, IMVFBINDEX8, 0 },
{ IN,1,2, RLE|C, IMVFBINDEX8, C },
{ IN,1,3, RLE, IMVFBINDEX8, 0 },
{ IN,1,3, RLE|C, IMVFBINDEX8, C },
{ IN,1,4, RLE, IMVFBINDEX8, 0 },
{ IN,1,4, RLE|C, IMVFBINDEX8, C },
{ IN,1,8, RLE, IMVFBINDEX8, 0 },
{ IN,1,8, RLE|C, IMVFBINDEX8, C },
{ -1, 0, -1, 0 },
};
static ImFileFormatWriteMap imPcxWriteMap[ ] =
{
/* in out */
/* VFB type, attr., type,ch,dep, attr., func */
{ IMVFBMONO, 0, IN,1,1, RLE, imPcxWrite1 },
{ IMVFBINDEX8, 0, IN,1,8, RLE, imPcxWrite8 },
{ IMVFBINDEX8, C, IN,1,8, RLE| C, imPcxWrite8 },
{ -1, 0, -1, 0, NULL },
};
static ImFileMagic imFilePcxMagic[]=
{
{ 0, 1, imPcxMagicNumber },
{ 0, 0, NULL },
};
ImFileFormat ImFilePcxFormat =
{
imPcxNames, "ZSoft IBM PC Paintbrush file",
"ZSoft Corp.",
"1-bit monochrome (CGA), 2-bit, 3-bit, and 4-bit color (EGA) files\n\
with or without a color table, and 8-bit color (VGA) files with or\n\
without a color table. All are RLE-encoded.",
"1-bit monochrome (CGA), and 8-bit color (VGA) files with or\n\
without a color table. All are RLE-encoded.",
imFilePcxMagic,
IMNOMULTI, IMNOPIPE,
IMNOMULTI, IMPIPE,
imPcxRead, imPcxReadMap, imPcxWriteMap
};
/*
* TYPEDEF & STRUCT
* imPcxHeaderInfo - header for PCX files
* imPcxHeaderFields - header description for binary I/O package
*
* DESCRIPTION
* PCX files start with a header that gives various details of the
* image contained in the file.
*/
typedef struct imPcxHeaderInfo /* PCX */
{
unsigned char pcx_manufacturer;
unsigned char pcx_version;
unsigned char pcx_encoding;
unsigned char pcx_bitsPerPixel;
unsigned short pcx_window[4];
unsigned short pcx_horizontalRes;
unsigned short pcx_verticalRes;
unsigned char pcx_clt[16][3];
unsigned char pcx_reserved;
unsigned char pcx_nPlanes;
unsigned short pcx_bytesPerLine;
unsigned short pcx_cltType;
unsigned char pcx_filler[58];
} imPcxHeaderInfo;
static BinField imPcxHeaderFields[ ] =
{
/* pcx_manufacturer */ UCHAR, 1, 1,
/* pcx_version */ UCHAR, 1, 1,
/* pcx_encoding */ UCHAR, 1, 1,
/* pcx_bitsPerPixel */ UCHAR, 1, 1,
/* pcx_window */ USHORT, 2, 4,
/* pcx_horizontalRes */ USHORT, 2, 1,
/* pcx_verticalRes */ USHORT, 2, 1,
/* pcx_clt */ UCHAR, 1, 48,
/* pcx_reserved */ UCHAR, 1, 1,
/* pcx_nPlanes */ UCHAR, 1, 1,
/* pcx_bytesPerLine */ USHORT, 2, 1,
/* pcx_cltType */ USHORT, 2, 1,
/* pcx_filler */ UCHAR, 1, 58,
0, 0, 0,
};
#define IMPCXHEADERSIZE (128)
/*
* Value for fields:
*/
#define IMPCXMANUFACTURER 0x0A /* ZSoft .PCX */
#define IMPCXV_2_5 0 /* Version 2.5 */
#define IMPCXV_2_8W 2 /* Version 2.8 w/clt */
#define IMPCXV_2_8WO 3 /* Version 2.8 wo/clt */
#define IMPCXV_3_0 5 /* Version 3.0 */
#define IMPCXENCODING 1 /* Run-length encoded */
#define IMPCXCOLOR 1 /* Color or BW CLT */
#define IMPCXGRAY 2 /* Grayscale CLT */
#define IMPCXPAINTBRUSH 2992 /* Strange PC Paintbrush type */
/*
* FUNCTION
* imPcxDecode - decode a run buffer
*
* DESCRIPTION
* An incomming encoded data buffer is decoded into a second buffer.
*/
static int /* Returns # of bytes decoded */
#ifdef __STDC__
imPcxDecode( unsigned char *src, int nDst, unsigned char *dst )
#else
imPcxDecode( src, nDst, dst )
unsigned char *src; /* Source buffer (encoded) */
int nDst; /* # of bytes in destination buffer*/
unsigned char *dst; /* Destination buffer (decoded) */
#endif
{
int i; /* Counter */
unsigned char value; /* Run value */
unsigned char *dstLast; /* Last byte +1 of dst buffer */
unsigned char *srcSave; /* Saved src pointer */
srcSave = src;
dstLast = dst + nDst;
while ( dst < dstLast )
{
if ( (*src & 0xC0) != 0xC0 )
*dst++ = *src++;
else
{
i = *src++ & 0x3F;
for ( value = *src++; i; i-- )
*dst++ = value;
}
}
return ( src - srcSave );
}
/*
* FUNCTION
* imPcxEncode - encode a run buffer
*
* DESCRIPTION
* An incomming data buffer is encoded into a second buffer. Bytes
* with their upper two bits set are flagged and stored as runs of 1.
*
* Note: becuase the upper two bits of a byte flag a run, we get two
* special cases to watch for:
* 1. The maximum run length is 63 (lower 6 bits set).
* 2. Data bytes with the upper two bits set have to be
* treated as runs of 1.
*/
static int /* Returns # of bytes encoded */
#ifdef __STDC__
imPcxEncode( unsigned char *src, int nSrc, unsigned char *dst )
#else
imPcxEncode( src, nSrc, dst )
unsigned char *src; /* Source buffer (encoded) */
int nSrc; /* # of bytes in source buffer */
unsigned char *dst; /* Destination buffer (decoded) */
#endif
{
int run; /* Run count */
unsigned char *srcLast; /* Last byte +1 of source buffer*/
unsigned char *dstSave; /* Saved original dst value */
srcLast = src + nSrc - 1;
dstSave = dst;
while ( src <= srcLast )
{
run = 0;
while ( *src == *(src+1) && src < srcLast && run < 62 )
{
run++;
src++;
}
if ( run > 0 )
*dst++ = (run + 1) | 0xC0;/* Store the run count*/
else if ( (*src & 0xC0) == 0xC0 )
*dst++ = 1 | 0xC0; /* Make it a run of 1 */
*dst++ = *src++;
}
return ( dst - dstSave );
}
/*
* FUNCTION
* imPcxRead - read a PCX file
*
* DESCRIPTION
* The file header is read and checked. The color table, if any, is
* read in. The image data is read in and decoded, then dispersed into
* a VFB of the appropriate depth. The VFB and CLT are added to the
* tag table.
*/
static int /* Returns # tags read in */
#ifdef __STDC__
imPcxRead( int ioType, int fd, FILE *fp, TagTable *flagsTable, TagTable *tagTable )
#else
imPcxRead( ioType, fd, fp, flagsTable, tagTable )
int ioType; /* I/O flags */
int fd; /* Input file descriptor */
FILE *fp; /* Input file pointer */
TagTable *flagsTable; /* Flags */
TagTable *tagTable; /* Tag table to add to */
#endif
{
ImVfb *vfb; /* Read in image */
ImVfbPtr pPixel; /* Pcxel pointer */
ImClt *clt; /* Image CLT */
ImCltPtr pColor; /* Color pointer */
unsigned char cltBuffer[769]; /* VGA card palette */
unsigned char *pCltBuffer; /* Buffer pointer */
unsigned char *encoded; /* Encoded scanline buffer */
unsigned char *decoded; /* Decoded scanline buffer */
unsigned char *pDecoded; /* Decoded buffer pointer */
unsigned char value; /* Pixel value */
unsigned char value2; /* Old pixel value */
imPcxHeaderInfo header; /* PCX file header */
int height, width; /* Image dimensions */
int width8; /* Width / 8 */
int widthextra; /* Width % 8 */
int n; /* Byte count */
int i, j; /* Counter */
int x, y; /* Current scanline */
int cltInHeader; /* Get the CLT from the header */
int cltAtEnd; /* Get the CLT from the EOF */
long cltFilePosition; /* File position of CLT */
long imageFilePosition; /* File position of Image */
char message[100]; /* ImInfo message */
/*
* Read in the header in LBF (Intel) byte order. Check that it is
* valid.
*/
BinByteOrder( BINLBF );
if ( ImBinReadStruct( ioType, fd, fp, &header, imPcxHeaderFields )== -1)
ImReturnBinError( );
if ( header.pcx_manufacturer != IMPCXMANUFACTURER )
ImErrorFatal( "Bad manufacturer code in PCX file header", -1, IMESYNTAX );
switch ( header.pcx_version )
{
case IMPCXV_2_5:
ImInfo( "Version", "2.5" );
break;
case IMPCXV_2_8W:
ImInfo( "Version", "2.8 with Palette" );
break;
case IMPCXV_2_8WO:
ImInfo( "Version", "2.8 without Palette" );
break;
case IMPCXV_3_0:
ImInfo( "Version", "3.0" );
break;
default:
ImErrorFatal( "Unknown file version in PCX file header", -1, IMESYNTAX );
}
if ( header.pcx_encoding != IMPCXENCODING )
ImErrorFatal( "Unknown encoding method in PCX file header", -1, IMESYNTAX );
switch ( header.pcx_bitsPerPixel )
{
case 1: /* 1-bit monochrome (CGA) */
/* 2-bit color (EGA) */
/* 3-bit color (EGA) */
/* 4-bit color (EGA) */
if ( header.pcx_nPlanes > 4 )
ImErrorFatal( "Bad color plane count in PCX file header", -1, IMESYNTAX );
if ( header.pcx_version == IMPCXV_2_8WO )
cltInHeader = FALSE;
else
cltInHeader = TRUE;
cltAtEnd = FALSE;
break;
case 8: /* 8-bit color (VGA) */
if ( header.pcx_nPlanes != 1 )
ImErrorFatal( "Bad color plane count in PCX file header", -1, IMESYNTAX );
cltInHeader = FALSE;
cltAtEnd = TRUE;
break;
default:
ImErrorFatal( "Unknown image depth. Must be 1, 4, or 8.", -1, IMESYNTAX );
}
width = header.pcx_window[2] - header.pcx_window[0] + 1;
height = header.pcx_window[3] - header.pcx_window[1] + 1;
switch ( header.pcx_cltType )
{
case 0: /* For backwards compatibility */
case IMPCXCOLOR:
case IMPCXGRAY:
case IMPCXPAINTBRUSH:
break;
default:
ImErrorFatal( "Unknown palette type in PCX file header", -1, IMESYNTAX );
}
ImInfo( "Byte Order", "Least Significant Byte First" );
sprintf( message, "%d x %d", width, height );
ImInfo( "Resolution", message );
sprintf( message, "%d-bit Color Indexed", header.pcx_bitsPerPixel);
ImInfo( "Type", message );
/*
* Make a CLT if we need one.
*/
clt = IMCLTNULL;
if ( cltInHeader )
{
/* 16-color CLT included in header. */
if ( (clt = ImCltAlloc( 16 )) == IMCLTNULL )
ImErrorFatal( ImQError( ), -1, ImErrNo );
pColor = ImCltQFirst( clt );
for ( i = 0; i < 16; i++ )
{
ImCltSRed( pColor, header.pcx_clt[i][0] );
ImCltSGreen( pColor, header.pcx_clt[i][1] );
ImCltSBlue( pColor, header.pcx_clt[i][2] );
ImCltSInc( clt, pColor );
}
ImInfo( "Color Table", "16 Entries" );
}
else if ( cltAtEnd )
{
/*
* Seek to 769 bytes from the bottom and see if there
* is a 0x0C there. If so, we've got a 256 entry palette.
*
* HOWEVER, there is the chance that seeking to 769 bytes
* from the end will put us within the image data if there
* really isn't a CLT. If that next image data byte just
* happened to be a 0x0C, then we'd falsely conclude there
* was a CLT. This is a problem in the PCX spec.
*
* To handle this case, we remember where things are and
* later compare where we got the alleged CLT versus the
* end of the image data. If it is too early in the file,
* we were fooled and we get rid of the bogus CLT.
*/
imageFilePosition = ImTell( ioType, fd, fp );
ImSeek( ioType, fd, fp, -769, 2 );
cltFilePosition = ImTell( ioType, fd, fp );
n = ImBinRead( ioType, fd, fp, cltBuffer, UCHAR, 1, 769 );
if ( n != -1 && *cltBuffer == 0x0C )
{
if ( (clt = ImCltAlloc( 256 )) == IMCLTNULL )
ImErrorFatal( ImQError( ), -1, ImErrNo );
pColor = ImCltQFirst( clt );
pCltBuffer = cltBuffer + 1;
for ( i = 0; i < 256; i++ )
{
ImCltSRed( pColor, *pCltBuffer++ );
ImCltSGreen( pColor, *pCltBuffer++ );
ImCltSBlue( pColor, *pCltBuffer++ );
ImCltSInc( clt, pColor );
}
ImInfo( "Color Table", "256 Entries" );
}
else
{
ImInfo( "Color Table", "none" );
}
ImSeek( ioType,fd, fp, IMPCXHEADERSIZE, 0 );
}
ImInfo( "Compression Type", "Run Length Encoded (RLE)" );
/*
* Read in the image data. Unfortunately, because it is encoded,
* we don't know how much data there is. We do know our worst
* case encoding could produce a file twice the size of the image.
* So, we allocate a buffer that big and try to read that much
* data. It is very likely that BinRead will return less than
* that. Fine. We then decode that buffer into a new buffer
* that is the size of the image (in bytes).
*/
n = header.pcx_bytesPerLine * header.pcx_nPlanes * height;
ImMalloc( encoded, unsigned char *, 2 * n );
ImMalloc( decoded, unsigned char *, n );
if ( ImBinRead( ioType, fd, fp, encoded, UCHAR, 1, 2 * n ) == -1 )
{
free( (char *)encoded );
free( (char *)decoded );
if ( clt != IMCLTNULL )
ImCltFree( clt );
ImReturnBinError( );
}
n = imPcxDecode( encoded, n, decoded );
/*
* If the location at which we found the CLT is within the image
* data we just read in, then there wasn't really a CLT there at
* all. It just happened that seeking to 769 bytes from the end
* fell upon a 0x0C within the image data, and we falsly concluded
* there was a CLT. We fix our mistake now.
*/
if ( cltAtEnd && imageFilePosition + n > cltFilePosition )
{
ImCltFree( clt );
clt = IMCLTNULL;
}
/*
* Walk the decoded buffer and expand it into a new VFB.
*/
if ( header.pcx_bitsPerPixel == 1 && header.pcx_nPlanes == 1 )
{
/*
* Monochrome. The decoded buffer contains packed bytes,
* each holding 8 1-bit pixel values. Watch for widths that
* are not a multiple of 8, and remember to toss an extra
* byte at the end of each scanline if the width (in bytes)
* is not even.
*/
if ( (vfb=ImVfbAlloc( width, height, IMVFBMONO )) == IMVFBNULL )
{
free( (char *)encoded );
free( (char *)decoded );
if ( clt != IMCLTNULL )
ImCltFree( clt );
ImErrorFatal( ImQError( ), -1, ImErrNo );
}
pPixel = ImVfbQFirst( vfb );
pDecoded = decoded;
width8 = width / 8; /* Width in bytes*/
widthextra = width & 0xF; /* width % 8 */
for ( y = 0; y < height; y++ )
{
for ( x = 0; x < width8; x++ )
{
value = *pDecoded++;
for ( i = 7; i >= 0; i-- )
{
ImVfbSMono( vfb, pPixel,
(value>>i) & 0x1 );
ImVfbSInc( vfb, pPixel );
}
}
if ( widthextra )
{
value = *pDecoded++;
for ( i = 7; i >= (8-widthextra); i-- )
{
ImVfbSMono( vfb, pPixel,
(value>>i) & 0x1 );
ImVfbSInc( vfb, pPixel );
}
}
/*
* According to the spec, we only have to skip a
* byte if the width is odd. However, some packages
* don't adhear to the even-byte-count requirement
* (such as PBM+). So, we only skip if the header
* says we should, and then as much as it says we
* should.
*/
for ( i = width8 + (widthextra?1:0);
i < header.pcx_bytesPerLine; i++ )
pDecoded++; /* Skip */
}
}
else if ( header.pcx_bitsPerPixel == 1 )
{
/*
* n-bit color (usually 4-bit). The decoded buffer contains
* packed bytes, each holding 8 1-bit pixel values... yes,
* 1-bit pixel values! Each scanline is stored as nPlanes
* of 1-bit planes. We need to remember to toss an extra
* byte per set if each scanline plane set's byte count is
* not even.
*/
if ( (vfb=ImVfbAlloc( width, height, IMVFBINDEX8 ))==IMVFBNULL )
{
free( (char *)encoded );
free( (char *)decoded );
if ( clt != IMCLTNULL )
ImCltFree( clt );
ImErrorFatal( ImQError( ), -1, ImErrNo );
}
pDecoded = decoded;
width8 = width / 8; /* Width in bytes*/
widthextra = width & 0xF; /* width % 8 */
for ( y = 0; y < height; y++ )
{
/* First plane. */
pPixel = ImVfbQPtr( vfb, 0, y );
for ( x = 0; x < width8; x++ )
{
value = *pDecoded++;
for ( i = 7; i >= 0; i-- )
{
ImVfbSIndex8( vfb, pPixel,
((value>>i) & 0x1) );
ImVfbSInc( vfb, pPixel );
}
}
if ( widthextra )
{
value = *pDecoded++;
for ( i = 7; i >= (8-widthextra); i-- )
{
ImVfbSIndex8( vfb, pPixel,
((value>>i) & 0x1) );
ImVfbSInc( vfb, pPixel );
}
}
/* Additional planes. */
for ( j = 1; j < header.pcx_nPlanes; j++ )
{
pPixel = ImVfbQPtr( vfb, 0, y );
for ( x = 0; x < width8; x++ )
{
value = *pDecoded++;
for ( i = 7; i >= 0; i-- )
{
value2 = ImVfbQIndex8( vfb,
pPixel );
ImVfbSIndex8( vfb, pPixel,
value2 |
((value>>i) & 0x1)<<j );
ImVfbSInc( vfb, pPixel );
}
}
if ( widthextra )
{
value = *pDecoded++;
for ( i = 7; i >= (8-widthextra); i-- )
{
value2 = ImVfbQIndex8( vfb,
pPixel );
ImVfbSIndex8( vfb, pPixel,
value2 |
((value>>i) & 0x1)<<j );
ImVfbSInc( vfb, pPixel );
}
}
}
/*
* According to the spec, we only have to skip a
* byte if the width is odd (note: width includes
* bytes for all the planes for one scanline).
* However, some packages don't adhear to the
* even-byte-count requirement (such as PBM+). So
* we only skip if the header says we should, and
* then as much as it says we should.
*/
for ( i = (width8+(widthextra?1:0))*header.pcx_nPlanes;
i < header.pcx_bytesPerLine; i++ )
pDecoded++; /* Skip */
}
}
else
{
/*
* 8-bit color. The decoded buffer contains one byte per
* pixel. We just copy it out and into the VFB. We need
* to toss a byte for each scanline if the width is not
* even.
*/
if ( (vfb=ImVfbAlloc( width, height, IMVFBINDEX8 ))==IMVFBNULL )
{
free( (char *)encoded );
free( (char *)decoded );
if ( clt != IMCLTNULL )
ImCltFree( clt );
ImErrorFatal( ImQError( ), -1, ImErrNo );
}
pPixel = ImVfbQFirst( vfb );
pDecoded = decoded;
for ( y = 0; y < height; y++ )
{
for ( x = 0; x < width; x++ )
{
ImVfbSIndex8( vfb, pPixel, *pDecoded++ );
ImVfbSInc( vfb, pPixel );
}
/*
* According to the spec, we only have to skip a
* byte if the width is odd. However, some packages
* don't adhear to the even-byte-count requirement
* (such as PBM+). So, we only skip if the header
* says we should, and then as much as it says we
* should.
*/
for ( i = width; i < header.pcx_bytesPerLine; i++ )
*pDecoded++; /* Skip */
}
}
/*
* Clean up.
*/
free( (char *)encoded );
free( (char *)decoded );
/*
* Add the VFB to the tagTable.
*/
if ( clt != IMCLTNULL )
{
ImVfbSClt( vfb, clt );
TagTableAppend( tagTable,
TagEntryAlloc( "image clt", POINTER, &clt ) );
TagTableAppend( tagTable,
TagEntryAlloc( "image vfb", POINTER, &vfb ) );
return ( 2 );
}
TagTableAppend( tagTable,
TagEntryAlloc( "image vfb", POINTER, &vfb ) );
return ( 1 );
}
/*
* FUNCTION
* imPcxWrite1 - write a 1-bit PCX file
*
* DESCRIPTION
* The PCX file header set up and written out followed by the encoded
* image data.
*/
static int /* Returns # of tags used */
#ifdef __STDC__
imPcxWrite1( ImFileFormatWriteMap *pMap, int ioType, int fd, FILE *fp, TagTable *flagsTable, TagTable *tagTable )
#else
imPcxWrite1( pMap, ioType, fd, fp, flagsTable, tagTable )
ImFileFormatWriteMap *pMap; /* Write map entry to adhear to */
int ioType; /* I/O flags */
int fd; /* Input file descriptor */
FILE *fp; /* Input file pointer */
TagTable *flagsTable; /* Flags */
TagTable *tagTable; /* Tag table to read from */
#endif
{
ImVfb *vfb; /* Read in image */
ImVfbPtr pPixel; /* Pixel pointer */
imPcxHeaderInfo header; /* PCX file header */
unsigned char *encoded; /* Encoded data buffer */
unsigned char *decoded; /* Decoded data buffer */
unsigned char *pDecoded; /* Encoded buffer pointer */
int n; /* Byte count */
int x, y; /* Pixel counters */
int i; /* Counter */
int value; /* Pixel value */
int height, width; /* Image size */
int width8; /* Width in bytes */
int widthextra; /* Extra bits in last byte */
char message[100]; /* ImInfo message */
/*
* Set up the header and write it out.
*/
TagEntryQValue( TagTableQDirect( tagTable, "image vfb", 0 ), &vfb );
width = ImVfbQWidth( vfb );
height = ImVfbQHeight( vfb );
BinByteOrder( BINLBF );
memset( (void *)&header, 0x00, sizeof( header ) );
header.pcx_manufacturer = IMPCXMANUFACTURER;
header.pcx_version = IMPCXV_2_5; /* No color */
header.pcx_encoding = IMPCXENCODING;
header.pcx_bitsPerPixel = 1; /* Monochrome */
header.pcx_window[0] = 0; /* xmin */
header.pcx_window[1] = 0; /* ymin */
header.pcx_window[2] = width - 1; /* xmax (minus 1) */
header.pcx_window[3] = height - 1; /* ymax (minus 1) */
header.pcx_nPlanes = 1; /* Monochrome */
header.pcx_bytesPerLine = (width + 7)/8;
if ( header.pcx_bytesPerLine & 0x1 )
++header.pcx_bytesPerLine; /* Make it even */
header.pcx_cltType = 0; /* Not relevant */
header.pcx_clt[0][0] = 0; /* Black */
header.pcx_clt[0][1] = 0;
header.pcx_clt[0][2] = 0;
header.pcx_clt[1][0] = 255; /* White */
header.pcx_clt[1][1] = 255;
header.pcx_clt[1][2] = 255;
/* Remaining fields left zero. */
if ( ImBinWriteStruct( ioType, fd, fp, &header, imPcxHeaderFields )==-1)
{
ImReturnBinError( );
}
/*
* Output -verbose message
*/
ImInfo( "Version", "2.5" );
ImInfo( "Byte Order", "Least Significant Byte First" );
sprintf( message, "%d x %d", width, height );
ImInfo( "Resolution", message);
ImInfo( "Type", "1-bit Color Indexed" );
ImInfo( "Color Table", "16 Entries" );
ImInfo( "Compression Type", "Run Length Encoded (RLE)" );
/*
* Buffer up, encode, and write out the image data. Remember that
* an encoded buffer could take up twice as much space as the
* decoded one, in the pathelogical case.
*/
ImMalloc( decoded, unsigned char *, header.pcx_bytesPerLine );
ImMalloc( encoded, unsigned char *, 2 * header.pcx_bytesPerLine );
memset( (void *)decoded, 0x00, header.pcx_bytesPerLine );
width8 = width / 8; /* # of bytes */
widthextra = width & 0xF; /* width % 8 */
pPixel = ImVfbQFirst( vfb );
for ( y = 0; y < height; y++ )
{
pDecoded = decoded;
for ( x = 0; x < width8; x++ )
{
value = 0;
for ( i = 7; i >= 0; i-- )
{
value |= (ImVfbQMono( vfb, pPixel ) & 0x1) << i;
ImVfbSInc( vfb, pPixel );
}
*pDecoded++ = value;
}
if ( widthextra )
{
value = 0;
for ( i = 7; i >= (8-widthextra); i-- )
{
value |= (ImVfbQMono( vfb, pPixel ) & 0x1) << i;
ImVfbSInc( vfb, pPixel );
}
*pDecoded++ = value;
}
/*
* Encoded it and write it out.
*/
n = imPcxEncode( decoded, header.pcx_bytesPerLine, encoded );
if ( ImBinWrite( ioType, fd, fp, encoded, UCHAR, 1, n ) == -1 )
{
free( (char *)encoded );
free( (char *)decoded );
ImReturnBinError( );
}
}
free( (char *)encoded );
free( (char *)decoded );
return ( 1 );
}
/*
* FUNCTION
* imPcxWrite8 - write an 8-bit PCX file
*
* DESCRIPTION
* The PCX file header set up and written out followed by the encoded
* image data.
*/
static int /* Returns # of tags used */
#ifdef __STDC__
imPcxWrite8( ImFileFormatWriteMap *pMap, int ioType, int fd, FILE *fp, TagTable *flagsTable, TagTable *tagTable )
#else
imPcxWrite8( pMap, ioType, fd, fp, flagsTable, tagTable )
ImFileFormatWriteMap *pMap; /* Write map entry to adhear to */
int ioType; /* I/O flags */
int fd; /* Input file descriptor */
FILE *fp; /* Input file pointer */
TagTable *flagsTable; /* Flags */
TagTable *tagTable; /* Tag table to read from */
#endif
{
ImVfb *vfb; /* Read in image */
ImVfbPtr pPixel; /* Pixel pointer */
ImClt *clt; /* Color lookup table */
ImCltPtr pColor; /* Color pointer */
imPcxHeaderInfo header; /* PCX file header */
unsigned char *encoded; /* Encoded data buffer */
unsigned char *decoded; /* Decoded data buffer */
unsigned char *pDecoded; /* Encoded buffer pointer */
unsigned char *colorBuf; /* Color table output buffer */
unsigned char *pColorBuf; /* Color table buffer pointer */
int n; /* Byte count */
int i, j; /* Color counters */
int x, y; /* Pixel counters */
int height, width; /* Image size */
char message[100]; /* ImInfo message */
/*
* Set up the header and write it out.
*/
TagEntryQValue( TagTableQDirect( tagTable, "image vfb", 0 ), &vfb );
clt = ImVfbQClt( vfb );
width = ImVfbQWidth( vfb );
height = ImVfbQHeight( vfb );
BinByteOrder( BINLBF );
memset( (void *)&header, 0x00, sizeof( header ) );
header.pcx_manufacturer = IMPCXMANUFACTURER;
header.pcx_version = IMPCXV_3_0; /* VGA color */
header.pcx_encoding = IMPCXENCODING;
header.pcx_bitsPerPixel = 8; /* 8-bit color */
header.pcx_window[0] = 0; /* xmin */
header.pcx_window[1] = 0; /* ymin */
header.pcx_window[2] = width - 1; /* xmax (minus 1) */
header.pcx_window[3] = height - 1; /* ymax (minus 1) */
header.pcx_nPlanes = 1; /* 1 color plane */
header.pcx_bytesPerLine = width;
if ( header.pcx_bytesPerLine & 0x1 )
++header.pcx_bytesPerLine; /* Make it even */
header.pcx_cltType = IMPCXCOLOR; /* Yup, its color */
/* Remaining fields left zero. */
if ( ImBinWriteStruct( ioType, fd, fp, &header, imPcxHeaderFields )==-1)
{
ImReturnBinError( );
}
/*
* Output -verbose message
*/
ImInfo( "Version", "3.0" );
ImInfo( "Byte Order", "Least Significant Byte First" );
sprintf( message, "%d x %d", width, height );
ImInfo( "Resolution", message);
ImInfo( "Type", "8-bit Color Indexed" );
ImInfo( "Color Table", "256 Entries" );
ImInfo( "Compression Type", "Run Length Encoded (RLE)" );
/*
* Buffer up, encode, and write out the image data. Remember that
* an encoded buffer could take up twice as much space as the
* decoded one, in the pathelogical case.
*/
ImMalloc( decoded, unsigned char *, header.pcx_bytesPerLine );
ImMalloc( encoded, unsigned char *, 2 * header.pcx_bytesPerLine );
memset( (void *)decoded, 0x00, header.pcx_bytesPerLine );
pPixel = ImVfbQFirst( vfb );
for ( y = 0; y < height; y++ )
{
pDecoded = decoded;
for ( x = 0; x < width; x++ )
{
*pDecoded++ = ImVfbQIndex8( vfb, pPixel ) & 0xFF;
ImVfbSInc( vfb, pPixel );
}
/*
* Encoded it and write it out.
*/
n = imPcxEncode( decoded, header.pcx_bytesPerLine, encoded );
if ( ImBinWrite( ioType, fd, fp, encoded, UCHAR, 1, n ) == -1 )
{
free( (char *)encoded );
free( (char *)decoded );
ImReturnBinError( );
}
}
free( (char *)encoded );
free( (char *)decoded );
/*
* Write out the color table (if any). Remember to start off the
* color table with the special "yes it's here" byte: 0x0C.
*/
if ( clt == IMCLTNULL )
return ( 1 ); /* No color table */
n = 256 * 3 + 1; /* Always 256 entries */
ImMalloc( colorBuf, unsigned char *, n );
memset( (void *)colorBuf, 0x00, n );
pColorBuf = colorBuf;
*pColorBuf++ = 0x0C; /* Yes, it's here */
/* Fill in with CLT entries from the VFB. */
i = ImCltQNColors( clt );
pColor = ImCltQFirst( clt );
for ( j = 0; j < i; j++ )
{
*pColorBuf++ = ImCltQRed( pColor ) & 0xFF;
*pColorBuf++ = ImCltQGreen( pColor ) & 0xFF;
*pColorBuf++ = ImCltQBlue( pColor ) & 0xFF;
ImCltSInc( clt, pColor );
}
/* Pad to 256 entries. */
for ( ; j < 256; j++ )
{
*pColorBuf++ = 0;
*pColorBuf++ = 0;
*pColorBuf++ = 0;
}
/* Write it out. */
if ( ImBinWrite( ioType, fd, fp, colorBuf, UCHAR, 1, n ) == -1 )
{
free( (char *)colorBuf );
ImReturnBinError( );
}
free( (char *)colorBuf );
return ( 2 ); /* VFB + CLT */
}
Reference in a new issue Copy permalink