/* create wbmp
* -----------
* create an empty wbmp
*/
Wbmp *createwbmp(int width, int height, int color)
{
int i;
Wbmp *wbmp;
if((wbmp = (Wbmp *)gdMalloc(sizeof (Wbmp))) == NULL) {
return (NULL);
}
if(overflow2(sizeof(int), width)) {
gdFree(wbmp);
return NULL;
}
if(overflow2(sizeof(int) * width, height)) {
gdFree(wbmp);
return NULL;
}
if((wbmp->bitmap = (int *)gdMalloc(sizeof(int) * width * height)) == NULL) {
gdFree(wbmp);
return NULL;
}
wbmp->width = width;
wbmp->height = height;
for(i = 0; i < width * height; wbmp->bitmap[i++] = color);
return wbmp;
}
static ICON_bmp
create4Bitmap (pixel ** const pa, int const cols, int const rows,
colorhash_table const cht) {
/*
* How wide should the u1 string for each row be?
* each byte is 8 pixels, but must be a multiple of 4 bytes.
*/
ICON_bmp icBitmap;
int xBytes,y,x;
int wt = cols;
u1 ** rowData;
MALLOCVAR_NOFAIL(icBitmap);
wt >>= 1;
if (wt & 3) {
wt = (wt & ~3) + 4;
}
xBytes = wt;
MALLOCARRAY_NOFAIL(rowData, rows);
icBitmap->xBytes = xBytes;
icBitmap->data = rowData;
overflow2(xBytes, rows);
icBitmap->size = xBytes * rows;
for (y=0;y<rows;y++) {
u1 * row;
int byteOn = 0;
int nibble = 1; /* high nibble = 1, low nibble = 0; */
int value;
MALLOCARRAY_NOFAIL(row, xBytes);
memset (row, 0, xBytes);
rowData[rows-y-1] = row;
/*
* Check there's a pixel array, otherwise we're just faking this...
*/
if (pa) {
for (x=0;x<cols;x++) {
value = ppm_lookupcolor(cht, &pa[y][x]);
/*
* Shift it, if we're putting it in the high nibble.
*/
if (nibble) {
value <<= 4;
}
row[byteOn] |= value;
if (nibble) {
nibble = 0;
} else {
nibble = 1;
byteOn++;
}
}
}
}
return icBitmap;
}
gdImagePtr gdImageTrueColorAttachBuffer(int* buffer, int sx, int sy, int stride)
{
int i;
int height;
int* rowptr;
gdImagePtr im;
im = (gdImage *) malloc (sizeof (gdImage));
if (!im) {
return 0;
}
memset (im, 0, sizeof (gdImage));
#if 0
if (overflow2(sizeof (int *), sy)) {
return 0;
}
#endif
im->tpixels = (int **) malloc (sizeof (int *) * sy);
if (!im->tpixels) {
free(im);
return 0;
}
im->polyInts = 0;
im->polyAllocated = 0;
im->brush = 0;
im->tile = 0;
im->style = 0;
height = sy;
rowptr = buffer;
if (stride < 0) {
int startoff = (height - 1) * stride;
rowptr = buffer - startoff;
}
i = 0;
while (height--) {
im->tpixels[i] = rowptr;
rowptr += stride;
i++;
}
im->sx = sx;
im->sy = sy;
im->transparent = (-1);
im->interlace = 0;
im->trueColor = 1;
im->saveAlphaFlag = 0;
im->alphaBlendingFlag = 1;
im->thick = 1;
im->AA = 0;
im->cx1 = 0;
im->cy1 = 0;
im->cx2 = im->sx - 1;
im->cy2 = im->sy - 1;
return im;
}
static ICON_bmp
createAndBitmap (gray ** const ba, int const cols, int const rows,
gray const maxval) {
/*
* How wide should the u1 string for each row be?
* each byte is 8 pixels, but must be a multiple of 4 bytes.
*/
ICON_bmp icBitmap;
int xBytes,y,x;
int wt = cols;
u1 ** rowData;
MALLOCVAR_NOFAIL(icBitmap);
wt >>= 3;
if (wt & 3) {
wt = (wt & ~3) + 4;
}
xBytes = wt;
MALLOCARRAY_NOFAIL(rowData, rows);
icBitmap->xBytes = xBytes;
icBitmap->data = rowData;
overflow2(xBytes, rows);
icBitmap->size = xBytes * rows;
for (y=0;y<rows;y++) {
u1 * row;
int byteOn = 0;
int bitOn = 128;
MALLOCARRAY_NOFAIL(row, xBytes);
memset (row, 0, xBytes);
rowData[rows-y-1] = row;
/*
* Check there's a bit array, otherwise we're just faking this...
*/
if (ba) {
for (x=0;x<cols;x++) {
/* Black (bit clear) is transparent in PGM alpha maps,
* in ICO bit *set* is transparent.
*/
if (ba[y][x] <= maxval/2) row[byteOn] |= bitOn;
if (bitOn == 1) {
byteOn++;
bitOn = 128;
} else {
bitOn >>= 1;
}
}
}
}
return icBitmap;
}
/* append bytes to the end of a dynamic pointer */
static int
appendDynamic (dynamicPtr * dp, const void *src, int size)
{
int bytesNeeded;
char *tmp;
if (!dp->dataGood)
return FALSE;
/* bytesNeeded = dp->logicalSize + size; */
bytesNeeded = dp->pos + size;
if (bytesNeeded > dp->realSize)
{
/* 2.0.21 */
if (!dp->freeOK)
{
return FALSE;
}
if (overflow2(dp->realSize, 2)) {
return FALSE;
}
if (!gdReallocDynamic (dp, bytesNeeded * 2))
{
dp->dataGood = FALSE;
return FALSE;
}
}
/* if we get here, we can be sure that we have enough bytes
to copy safely */
/*printf("Mem OK Size: %d, Pos: %d\n", dp->realSize, dp->pos); */
tmp = (char *) dp->data;
memcpy ((void *) (tmp + (dp->pos)), src, size);
dp->pos += size;
if (dp->pos > dp->logicalSize)
{
dp->logicalSize = dp->pos;
};
return TRUE;
}
static int
dynamicSeek (struct gdIOCtx *ctx, const int pos)
{
int bytesNeeded;
dynamicPtr *dp;
dpIOCtx *dctx;
dctx = (dpIOCtx *) ctx;
dp = dctx->dp;
if (!dp->dataGood)
return FALSE;
bytesNeeded = pos;
if (bytesNeeded > dp->realSize)
{
/* 2.0.21 */
if (!dp->freeOK)
{
return FALSE;
}
if (overflow2(dp->realSize, 2)) {
return FALSE;
}
if (!gdReallocDynamic (dp, dp->realSize * 2))
{
dp->dataGood = FALSE;
return FALSE;
}
}
/* if we get here, we can be sure that we have enough bytes
to copy safely */
/* Extend the logical size if we seek beyond EOF. */
if (pos > dp->logicalSize)
{
dp->logicalSize = pos;
};
dp->pos = pos;
return TRUE;
}
static ICON_bmp
create8Bitmap (pixel ** const pa, int const cols, int const rows,
colorhash_table const cht) {
/*
* How wide should the u1 string for each row be?
* each byte is 8 pixels, but must be a multiple of 4 bytes.
*/
ICON_bmp icBitmap;
int xBytes,y,x;
int wt = cols;
u1 ** rowData;
MALLOCVAR_NOFAIL(icBitmap);
if (wt & 3) {
wt = (wt & ~3) + 4;
}
xBytes = wt;
MALLOCARRAY_NOFAIL(rowData, rows);
icBitmap->xBytes = xBytes;
icBitmap->data = rowData;
overflow2(xBytes, rows);
icBitmap->size = xBytes * rows;
for (y=0;y<rows;y++) {
u1 * row;
MALLOCARRAY_NOFAIL(row, xBytes);
memset (row, 0, xBytes);
rowData[rows-y-1] = row;
/*
* Check there's a pixel array, otherwise we're just faking this...
*/
if (pa) {
for (x=0;x<cols;x++) {
row[x] = ppm_lookupcolor(cht, &pa[y][x]);
}
}
}
return icBitmap;
}
BGD_DECLARE(gdImagePtr) gdImageCreateFromXpm(char *filename)
{
XpmInfo info;
XpmImage image;
unsigned int i, j, k, number, len;
char buf[5];
gdImagePtr im = 0;
int *pointer;
int red = 0, green = 0, blue = 0;
int *colors;
int ret;
ret = XpmReadFileToXpmImage(filename, &image, &info);
if(ret != XpmSuccess) {
return 0;
}
number = image.ncolors;
if(overflow2(sizeof(int), number)) {
goto done;
}
colors = (int *)gdMalloc(sizeof(int) * number);
if(colors == NULL) {
goto done;
}
if(!(im = gdImageCreate(image.width, image.height))) {
gdFree(colors);
goto done;
}
for(i = 0; i < number; i++) {
char *c_color = image.colorTable[i].c_color;
if(strcmp(c_color, "None") == 0) {
colors[i] = gdImageGetTransparent(im);
if(colors[i] == -1) colors[i] = gdImageColorAllocate(im, 0, 0, 0);
if(colors[i] != -1) gdImageColorTransparent(im, colors[i]);
continue;
}
len = strlen(c_color);
if(len < 1) continue;
if(c_color[0] == '#') {
switch(len) {
case 4:
buf[2] = '\0';
buf[0] = buf[1] = c_color[1];
red = strtol(buf, NULL, 16);
buf[0] = buf[1] = c_color[2];
green = strtol(buf, NULL, 16);
buf[0] = buf[1] = c_color[3];
blue = strtol(buf, NULL, 16);
break;
case 7:
buf[2] = '\0';
buf[0] = c_color[1];
buf[1] = c_color[2];
red = strtol(buf, NULL, 16);
buf[0] = c_color[3];
buf[1] = c_color[4];
green = strtol(buf, NULL, 16);
buf[0] = c_color[5];
buf[1] = c_color[6];
blue = strtol(buf, NULL, 16);
break;
case 10:
buf[3] = '\0';
buf[0] = c_color[1];
buf[1] = c_color[2];
buf[2] = c_color[3];
red = strtol(buf, NULL, 16);
red /= 64;
buf[0] = c_color[4];
buf[1] = c_color[5];
buf[2] = c_color[6];
green = strtol(buf, NULL, 16);
green /= 64;
buf[0] = c_color[7];
buf[1] = c_color[8];
buf[2] = c_color[9];
blue = strtol(buf, NULL, 16);
blue /= 64;
break;
case 13:
buf[4] = '\0';
buf[0] = c_color[1];
buf[1] = c_color[2];
buf[2] = c_color[3];
buf[3] = c_color[4];
red = strtol(buf, NULL, 16);
red /= 256;
buf[0] = c_color[5];
buf[1] = c_color[6];
buf[2] = c_color[7];
buf[3] = c_color[8];
green = strtol(buf, NULL, 16);
green /= 256;
buf[0] = c_color[9];
buf[1] = c_color[10];
buf[2] = c_color[11];
buf[3] = c_color[12];
blue = strtol(buf, NULL, 16);
blue /= 256;
break;
}
} else if(!gdColorMapLookup(GD_COLOR_MAP_X11, c_color, &red, &green, &blue)) {
continue;
}
colors[i] = gdImageColorResolve(im, red, green, blue);
}
pointer = (int *)image.data;
for(i = 0; i < image.height; i++) {
for(j = 0; j < image.width; j++) {
k = *pointer++;
gdImageSetPixel(im, j, i, colors[k]);
}
}
gdFree(colors);
done:
XpmFreeXpmImage(&image);
XpmFreeXpmInfo(&info);
return im;
}
/*
Function: gdImageCreateFromGd2Ctx
Reads in a GD2 image via a <gdIOCtx> struct. See
<gdImageCreateFromGd2>.
*/
BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2Ctx (gdIOCtxPtr in)
{
int sx, sy;
int i;
int ncx, ncy, nc, cs, cx, cy;
int x, y, ylo, yhi, xlo, xhi;
int vers, fmt;
t_chunk_info *chunkIdx = NULL; /* So we can gdFree it with impunity. */
unsigned char *chunkBuf = NULL; /* So we can gdFree it with impunity. */
int chunkNum = 0;
int chunkMax = 0;
uLongf chunkLen;
int chunkPos = 0;
int compMax = 0;
int bytesPerPixel;
char *compBuf = NULL; /* So we can gdFree it with impunity. */
gdImagePtr im;
/* Get the header */
im =
_gd2CreateFromFile (in, &sx, &sy, &cs, &vers, &fmt, &ncx, &ncy,
&chunkIdx);
if (im == NULL) {
/* No need to free chunkIdx as _gd2CreateFromFile does it for us. */
return 0;
}
bytesPerPixel = im->trueColor ? 4 : 1;
if (overflow2(ncx, ncy))
goto fail;
nc = ncx * ncy;
if (overflow2(ncy, cs) || overflow2(ncx, cs) || overflow2(bytesPerPixel, cs))
goto fail;
if (gd2_compressed (fmt)) {
/* Find the maximum compressed chunk size. */
compMax = 0;
for (i = 0; (i < nc); i++) {
if (chunkIdx[i].size > compMax) {
compMax = chunkIdx[i].size;
};
};
compMax++;
/* Allocate buffers */
chunkMax = cs * bytesPerPixel * cs;
chunkBuf = gdCalloc (chunkMax, 1);
if (!chunkBuf) {
goto fail;
}
compBuf = gdCalloc (compMax, 1);
if (!compBuf) {
goto fail;
}
GD2_DBG (printf ("Largest compressed chunk is %d bytes\n", compMax));
};
/* if ( (ncx != sx / cs) || (ncy != sy / cs)) { */
/* goto fail2; */
/* }; */
/* Read the data... */
for (cy = 0; (cy < ncy); cy++) {
for (cx = 0; (cx < ncx); cx++) {
ylo = cy * cs;
yhi = ylo + cs;
if (yhi > im->sy) {
yhi = im->sy;
};
GD2_DBG (printf
("Processing Chunk %d (%d, %d), y from %d to %d\n",
chunkNum, cx, cy, ylo, yhi));
if (gd2_compressed (fmt)) {
chunkLen = chunkMax;
if (!_gd2ReadChunk (chunkIdx[chunkNum].offset,
compBuf,
chunkIdx[chunkNum].size,
(char *) chunkBuf, &chunkLen, in)) {
GD2_DBG (printf ("Error reading comproessed chunk\n"));
goto fail;
};
chunkPos = 0;
};
for (y = ylo; (y < yhi); y++) {
xlo = cx * cs;
xhi = xlo + cs;
if (xhi > im->sx) {
xhi = im->sx;
};
/*GD2_DBG(printf("y=%d: ",y)); */
if (!gd2_compressed (fmt)) {
for (x = xlo; x < xhi; x++) {
if (im->trueColor) {
if (!gdGetInt (&im->tpixels[y][x], in)) {
gd_error("gd2: EOF while reading\n");
goto fail;
}
} else {
int ch;
if (!gdGetByte (&ch, in)) {
gd_error("gd2: EOF while reading\n");
goto fail;
}
im->pixels[y][x] = ch;
}
}
} else {
for (x = xlo; x < xhi; x++) {
if (im->trueColor) {
/* 2.0.1: work around a gcc bug by being verbose.
TBB */
int a = chunkBuf[chunkPos++] << 24;
int r = chunkBuf[chunkPos++] << 16;
int g = chunkBuf[chunkPos++] << 8;
int b = chunkBuf[chunkPos++];
/* 2.0.11: tpixels */
im->tpixels[y][x] = a + r + g + b;
} else {
im->pixels[y][x] = chunkBuf[chunkPos++];
}
};
};
/*GD2_DBG(printf("\n")); */
};
chunkNum++;
};
};
GD2_DBG (printf ("Freeing memory\n"));
gdFree (chunkBuf);
gdFree (compBuf);
gdFree (chunkIdx);
GD2_DBG (printf ("Done\n"));
return im;
fail:
gdImageDestroy (im);
if (chunkBuf) {
gdFree (chunkBuf);
}
if (compBuf) {
gdFree (compBuf);
}
if (chunkIdx) {
gdFree (chunkIdx);
}
return 0;
}
static int
_gd2GetHeader (gdIOCtxPtr in, int *sx, int *sy,
int *cs, int *vers, int *fmt, int *ncx, int *ncy,
t_chunk_info ** chunkIdx)
{
int i;
int ch;
char id[5];
t_chunk_info *cidx;
int sidx;
int nc;
GD2_DBG (printf ("Reading gd2 header info\n"));
for (i = 0; i < 4; i++) {
ch = gdGetC (in);
if (ch == EOF) {
goto fail1;
};
id[i] = ch;
};
id[4] = 0;
GD2_DBG (printf ("Got file code: %s\n", id));
/* Equiv. of 'magick'. */
if (strcmp (id, GD2_ID) != 0) {
GD2_DBG (printf ("Not a valid gd2 file\n"));
goto fail1;
};
/* Version */
if (gdGetWord (vers, in) != 1) {
goto fail1;
};
GD2_DBG (printf ("Version: %d\n", *vers));
if ((*vers != 1) && (*vers != 2)) {
GD2_DBG (printf ("Bad version: %d\n", *vers));
goto fail1;
};
/* Image Size */
if (!gdGetWord (sx, in)) {
GD2_DBG (printf ("Could not get x-size\n"));
goto fail1;
}
if (!gdGetWord (sy, in)) {
GD2_DBG (printf ("Could not get y-size\n"));
goto fail1;
}
GD2_DBG (printf ("Image is %dx%d\n", *sx, *sy));
/* Chunk Size (pixels, not bytes!) */
if (gdGetWord (cs, in) != 1) {
goto fail1;
};
GD2_DBG (printf ("ChunkSize: %d\n", *cs));
if ((*cs < GD2_CHUNKSIZE_MIN) || (*cs > GD2_CHUNKSIZE_MAX)) {
GD2_DBG (printf ("Bad chunk size: %d\n", *cs));
goto fail1;
};
/* Data Format */
if (gdGetWord (fmt, in) != 1) {
goto fail1;
};
GD2_DBG (printf ("Format: %d\n", *fmt));
if ((*fmt != GD2_FMT_RAW) && (*fmt != GD2_FMT_COMPRESSED) &&
(*fmt != GD2_FMT_TRUECOLOR_RAW) &&
(*fmt != GD2_FMT_TRUECOLOR_COMPRESSED)) {
GD2_DBG (printf ("Bad data format: %d\n", *fmt));
goto fail1;
};
/* # of chunks wide */
if (gdGetWord (ncx, in) != 1) {
goto fail1;
};
GD2_DBG (printf ("%d Chunks Wide\n", *ncx));
/* # of chunks high */
if (gdGetWord (ncy, in) != 1) {
goto fail1;
};
GD2_DBG (printf ("%d Chunks vertically\n", *ncy));
if (gd2_compressed (*fmt)) {
if (overflow2(*ncx, *ncy)) {
GD2_DBG(printf ("Illegal chunk counts: %d * %d\n", *ncx, *ncy));
goto fail1;
}
nc = (*ncx) * (*ncy);
GD2_DBG (printf ("Reading %d chunk index entries\n", nc));
if (overflow2(sizeof(t_chunk_info), nc)) {
goto fail1;
}
sidx = sizeof (t_chunk_info) * nc;
if (sidx <= 0) {
goto fail1;
}
cidx = gdCalloc (sidx, 1);
if (cidx == NULL) {
goto fail1;
}
for (i = 0; i < nc; i++) {
if (gdGetInt (&cidx[i].offset, in) != 1) {
goto fail2;
};
if (gdGetInt (&cidx[i].size, in) != 1) {
goto fail2;
};
if (cidx[i].offset < 0 || cidx[i].size < 0 || cidx[i].size == INT_MAX)
goto fail2;
};
*chunkIdx = cidx;
};
GD2_DBG (printf ("gd2 header complete\n"));
return 1;
fail2:
gdFree(cidx);
fail1:
return 0;
}
/*! \brief Reads a TGA image data into buffer.
* Reads the image data block from a binary TGA file populating the referenced TGA structure.
* \param ctx Pointer to TGA binary file
* \param tga Pointer to TGA structure
* \return int 0 on sucess, -1 on failure
*/
int read_image_tga( gdIOCtx *ctx, oTga *tga )
{
int pixel_block_size = (tga->bits / 8);
int image_block_size = (tga->width * tga->height) * pixel_block_size;
uint8_t* decompression_buffer = NULL;
unsigned char* conversion_buffer = NULL;
int buffer_caret = 0;
int bitmap_caret = 0;
int i = 0;
int encoded_pixels;
if(overflow2(tga->width, tga->height)) {
return -1;
}
if(overflow2(tga->width * tga->height, pixel_block_size)) {
return -1;
}
if(overflow2(image_block_size, sizeof(int))) {
return -1;
}
/*! \todo Add more image type support.
*/
if (tga->imagetype != TGA_TYPE_RGB && tga->imagetype != TGA_TYPE_RGB_RLE)
return -1;
/*! \brief Allocate memmory for image block
* Allocate a chunk of memory for the image block to be passed into.
*/
tga->bitmap = (int *) gdMalloc(image_block_size * sizeof(int));
if (tga->bitmap == NULL)
return -1;
switch (tga->imagetype) {
case TGA_TYPE_RGB:
/*! \brief Read in uncompressed RGB TGA
* Chunk load the pixel data from an uncompressed RGB type TGA.
*/
conversion_buffer = (unsigned char *) gdMalloc(image_block_size * sizeof(unsigned char));
if (conversion_buffer == NULL) {
return -1;
}
if (gdGetBuf(conversion_buffer, image_block_size, ctx) != image_block_size) {
gd_error("gd-tga: premature end of image data\n");
gdFree(conversion_buffer);
return -1;
}
while (buffer_caret < image_block_size) {
tga->bitmap[buffer_caret] = (int) conversion_buffer[buffer_caret];
buffer_caret++;
}
gdFree(conversion_buffer);
break;
case TGA_TYPE_RGB_RLE:
/*! \brief Read in RLE compressed RGB TGA
* Chunk load the pixel data from an RLE compressed RGB type TGA.
*/
decompression_buffer = (uint8_t*) gdMalloc(image_block_size * sizeof(uint8_t));
if (decompression_buffer == NULL) {
return -1;
}
conversion_buffer = (unsigned char *) gdMalloc(image_block_size * sizeof(unsigned char));
if (conversion_buffer == NULL) {
gd_error("gd-tga: premature end of image data\n");
gdFree( decompression_buffer );
return -1;
}
if (gdGetBuf(conversion_buffer, image_block_size, ctx) != image_block_size) {
gdFree(conversion_buffer);
gdFree(decompression_buffer);
return -1;
}
buffer_caret = 0;
while( buffer_caret < image_block_size) {
decompression_buffer[buffer_caret] = (int)conversion_buffer[buffer_caret];
buffer_caret++;
}
buffer_caret = 0;
while( bitmap_caret < image_block_size ) {
if ((decompression_buffer[buffer_caret] & TGA_RLE_FLAG) == TGA_RLE_FLAG) {
encoded_pixels = ( ( decompression_buffer[ buffer_caret ] & ~TGA_RLE_FLAG ) + 1 );
buffer_caret++;
if ((bitmap_caret + (encoded_pixels * pixel_block_size)) >= image_block_size) {
gdFree( decompression_buffer );
gdFree( conversion_buffer );
return -1;
}
for (i = 0; i < encoded_pixels; i++) {
memcpy(tga->bitmap + bitmap_caret, decompression_buffer + buffer_caret, pixel_block_size);
bitmap_caret += pixel_block_size;
}
buffer_caret += pixel_block_size;
} else {
encoded_pixels = decompression_buffer[ buffer_caret ] + 1;
buffer_caret++;
if ((bitmap_caret + (encoded_pixels * pixel_block_size)) >= image_block_size) {
gdFree( decompression_buffer );
gdFree( conversion_buffer );
return -1;
}
memcpy(tga->bitmap + bitmap_caret, decompression_buffer + buffer_caret, encoded_pixels * pixel_block_size);
bitmap_caret += (encoded_pixels * pixel_block_size);
buffer_caret += (encoded_pixels * pixel_block_size);
}
}
gdFree( decompression_buffer );
gdFree( conversion_buffer );
break;
}
return 1;
}
/* tiffWriter
* ----------
* Write the gd image as a tiff file (called by gdImageTiffCtx)
* Parameters are:
* image: gd image structure;
* out: the stream where to write
* bitDepth: depth in bits of each pixel
*/
BGD_DECLARE(void) tiffWriter(gdImagePtr image, gdIOCtx *out, int bitDepth)
{
int x, y;
int i;
int r, g, b, a;
TIFF *tiff;
int width, height;
int color;
char *scan;
int samplesPerPixel = 3;
int bitsPerSample;
int transparentColorR = -1;
int transparentColorG = -1;
int transparentColorB = -1;
uint16 extraSamples[1];
uint16 *colorMapRed = 0;
uint16 *colorMapGreen = 0;
uint16 *colorMapBlue = 0;
tiff_handle *th;
th = new_tiff_handle(out);
if (!th) {
return;
}
extraSamples[0] = EXTRASAMPLE_ASSOCALPHA;
/* read in the width/height of gd image */
width = gdImageSX(image);
height = gdImageSY(image);
/* reset clip region to whole image */
gdImageSetClip(image, 0, 0, width, height);
/* handle old-style single-colour mapping to 100% transparency */
if(image->transparent != 0xffffffff) {
/* set our 100% transparent colour value */
transparentColorR = gdImageRed(image, image->transparent);
transparentColorG = gdImageGreen(image, image->transparent);
transparentColorB = gdImageBlue(image, image->transparent);
}
/* Open tiff file writing routines, but use special read/write/seek
* functions so that tiff lib writes correct bits of tiff content to
* correct areas of file opened and modifieable by the gdIOCtx functions
*/
tiff = TIFFClientOpen("", "w", th, tiff_readproc,
tiff_writeproc,
tiff_seekproc,
tiff_closeproc,
tiff_sizeproc,
tiff_mapproc,
tiff_unmapproc);
TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, width);
TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, height);
TIFFSetField(tiff, TIFFTAG_COMPRESSION, COMPRESSION_DEFLATE);
TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC,
(bitDepth == 24) ? PHOTOMETRIC_RGB : PHOTOMETRIC_PALETTE);
bitsPerSample = (bitDepth == 24 || bitDepth == 8) ? 8 : 1;
TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, bitsPerSample);
/* build the color map for 8 bit images */
if(bitDepth != 24) {
colorMapRed = (uint16 *) gdMalloc(3 * (1 << bitsPerSample));
if (!colorMapRed) {
return;
}
colorMapGreen = (uint16 *) gdMalloc(3 * (1 << bitsPerSample));
if (!colorMapGreen) {
return;
}
colorMapBlue = (uint16 *) gdMalloc(3 * (1 << bitsPerSample));
if (!colorMapBlue) {
return;
}
for(i = 0; i < image->colorsTotal; i++) {
colorMapRed[i] = gdImageRed(image,i) + (gdImageRed(image,i) * 256);
colorMapGreen[i] = gdImageGreen(image,i)+(gdImageGreen(image,i)*256);
colorMapBlue[i] = gdImageBlue(image,i) + (gdImageBlue(image,i)*256);
}
TIFFSetField(tiff, TIFFTAG_COLORMAP, colorMapRed, colorMapGreen,
colorMapBlue);
samplesPerPixel = 1;
}
/* here, we check if the 'save alpha' flag is set on the source gd image */
if( (bitDepth == 24) &&
(image->saveAlphaFlag || image->transparent != 0xffffffff)) {
/* so, we need to store the alpha values too!
* Also, tell TIFF what the extra sample means (associated alpha) */
samplesPerPixel = 4;
TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, samplesPerPixel);
TIFFSetField(tiff, TIFFTAG_EXTRASAMPLES, 1, extraSamples);
} else {
TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, samplesPerPixel);
}
TIFFSetField(tiff, TIFFTAG_ROWSPERSTRIP, 1);
if(overflow2(width, samplesPerPixel)) {
return;
}
if(!(scan = (char *)gdMalloc(width * samplesPerPixel))) {
return;
}
/* loop through y-coords, and x-coords */
for(y = 0; y < height; y++) {
for(x = 0; x < width; x++) {
/* generate scan line for writing to tiff */
color = gdImageGetPixel(image, x, y);
a = (127 - gdImageAlpha(image, color)) * 2;
a = (a == 0xfe) ? 0xff : a & 0xff;
b = gdImageBlue(image, color);
g = gdImageGreen(image, color);
r = gdImageRed(image, color);
/* if this pixel has the same RGB as the transparent colour,
* then set alpha fully transparent */
if( transparentColorR == r &&
transparentColorG == g &&
transparentColorB == b
) {
a = 0x00;
}
if(bitDepth != 24) {
/* write out 1 or 8 bit value in 1 byte
* (currently treats 1bit as 8bit) */
scan[(x * samplesPerPixel) + 0] = color;
} else {
/* write out 24 bit value in 3 (or 4 if transparent) bytes */
if(image->saveAlphaFlag || image->transparent != 0xffffffff) {
scan[(x * samplesPerPixel) + 3] = a;
}
scan[(x * samplesPerPixel) + 2] = b;
scan[(x * samplesPerPixel) + 1] = g;
scan[(x * samplesPerPixel) + 0] = r;
}
}
/* Write the scan line to the tiff */
if(TIFFWriteEncodedStrip(tiff, y, scan, width * samplesPerPixel) == -1){
/* error handler here */
fprintf(stderr, "Could not create TIFF\n");
return;
}
}
/* now cloase and free up resources */
TIFFClose(tiff);
gdFree(scan);
gdFree(th);
if(bitDepth != 24) {
gdFree(colorMapRed);
gdFree(colorMapGreen);
gdFree(colorMapBlue);
}
}
static void
convertImage(FILE * const ofP,
struct cmdlineInfo const cmdline,
struct jpeg_decompress_struct * const cinfoP) {
int output_type;
/* The type of output file, PGM or PPM. Value is either PPM_TYPE
or PGM_TYPE, which conveniently also pass as format values
PPM_FORMAT and PGM_FORMAT.
*/
JSAMPROW jpegbuffer; /* Input buffer. Filled by jpeg_scanlines() */
unsigned int maxval;
/* The maximum value of a sample (color component), both in the input
and the output.
*/
enum colorspace color_space;
/* The color space of the pixels coming out of the JPEG decompressor */
beginJpegInput(cinfoP, cmdline.verbose,
cmdline.dct_method,
cmdline.max_memory_to_use, cmdline.nosmooth);
set_color_spaces(cinfoP->jpeg_color_space, &output_type,
&cinfoP->out_color_space);
maxval = (1 << cinfoP->data_precision) - 1;
if (cmdline.verbose)
tellDetails(*cinfoP, maxval, output_type);
/* Calculate output image dimensions so we can allocate space */
jpeg_calc_output_dimensions(cinfoP);
overflow2(cinfoP->output_width, cinfoP->output_components);
jpegbuffer = ((*cinfoP->mem->alloc_sarray)
((j_common_ptr) cinfoP, JPOOL_IMAGE,
cinfoP->output_width * cinfoP->output_components,
(JDIMENSION) 1)
)[0];
/* Start decompressor */
jpeg_start_decompress(cinfoP);
if (ofP)
/* Write pnm output header */
pnm_writepnminit(ofP, cinfoP->output_width, cinfoP->output_height,
maxval, output_type, FALSE);
pnmbuffer = pnm_allocrow(cinfoP->output_width);
color_space = computeColorSpace(cinfoP, cmdline.inklevel);
/* Process data */
while (cinfoP->output_scanline < cinfoP->output_height) {
jpeg_read_scanlines(cinfoP, &jpegbuffer, 1);
if (ofP)
copy_pixel_row(jpegbuffer, cinfoP->output_width,
cinfoP->out_color_components,
color_space, maxval, ofP, output_type);
}
if (cmdline.comments)
print_comments(*cinfoP);
if (cmdline.dumpexif)
dump_exif(*cinfoP);
if (cmdline.exif_filespec)
save_exif(*cinfoP, cmdline.exif_filespec);
pnm_freerow(pnmbuffer);
/* Finish decompression and release decompressor memory. */
jpeg_finish_decompress(cinfoP);
}
/* readwbmp
* -------
* Actually reads the WBMP format from an open file descriptor
* It goes along by returning a pointer to a WBMP struct.
*/
int readwbmp(int (*getin) (void *in), void *in, Wbmp **return_wbmp)
{
int row, col, byte, pel, pos;
Wbmp *wbmp;
if((wbmp = (Wbmp *)gdMalloc(sizeof(Wbmp))) == NULL) {
return -1;
}
wbmp->type = getin(in);
if(wbmp->type != 0) {
gdFree(wbmp);
return -1;
}
if(skipheader(getin, in)) {
return -1;
}
wbmp->width = getmbi(getin, in);
if(wbmp->width == -1) {
gdFree(wbmp);
return -1;
}
wbmp->height = getmbi(getin, in);
if(wbmp->height == -1) {
gdFree(wbmp);
return -1;
}
#ifdef __DEBUG
printf("W: %d, H: %d\n", wbmp->width, wbmp->height);
#endif
if( overflow2(sizeof(int), wbmp->width) ||
overflow2(sizeof(int) * wbmp->width, wbmp->height)) {
gdFree(wbmp);
return -1;
}
if((wbmp->bitmap = (int *)gdMalloc(sizeof(int) * wbmp->width * wbmp->height)) == NULL) {
gdFree(wbmp);
return -1;
}
#ifdef __DEBUG
printf("DATA CONSTRUCTED\n");
#endif
pos = 0;
for(row = 0; row < wbmp->height; row++) {
for(col = 0; col < wbmp->width;) {
byte = getin(in);
for(pel = 7; pel >= 0; pel--) {
if(col++ < wbmp->width) {
if(byte & 1 << pel) {
wbmp->bitmap[pos] = WBMP_WHITE;
} else {
wbmp->bitmap[pos] = WBMP_BLACK;
}
pos++;
}
}
}
}
*return_wbmp = wbmp;
return 0;
}
int
main(int argc, char **argv) {
int n, optstop = 0;
char *fname = NULL;
pbm_init(&argc, argv);
/* Parse options */
for (n = 1; n < argc; ++n) {
if (argv[n][0] == '-' && !optstop) {
if (argv[n][1] == 'a' || argv[n][1] == 'A') bAscii = 1;
if (argv[n][1] == 'd' || argv[n][1] == 'D') bScale = 1;
if (argv[n][1] == 'i' || argv[n][1] == 'I') bInvert = 1;
if (argv[n][1] == 'h' || argv[n][1] == 'H') usage(argv[0]);
if (argv[n][1] == '-' && argv[n][2] == 0 && !fname) {
/* "--" */
optstop = 1;
}
if (argv[n][1] == '-' && (argv[n][2] == 'h' || argv[n][2] == 'H'))
usage(argv[0]);
}
else if (argv[n][0] && !fname) {
/* Filename */
fname = argv[n];
}
}
if (fname)
infile = pm_openr(fname);
else
infile = stdin;
/* Read MDA file header */
if (fread(header, 1, 128, infile) < 128)
pm_error("Not a .MDA file\n");
if (strncmp((char*) header, ".MDA", 4) &&
strncmp((char*) header, ".MDP", 4))
pm_error("Not a .MDA file\n");
{
short yy;
pm_readlittleshort(infile, &yy); nInRows = yy;
pm_readlittleshort(infile, &yy); nInCols = yy;
}
overflow2(nOutCols, 8);
nOutCols = 8 * nInCols;
nOutRows = nInRows;
if (bScale) {
overflow2(nOutRows, 2);
nOutRows *= 2;
}
data = pbm_allocarray(nOutCols, nOutRows);
MALLOCARRAY_NOFAIL(mdrow, nInCols);
if (header[21] == '0')
md2_trans();
else
md3_trans();
pbm_writepbm(stdout, data, nInCols*8, nOutRows, bAscii);
if (infile != stdin)
pm_close(infile);
fflush(stdout);
pbm_freearray(data, nOutRows);
free(mdrow);
return 0;
}
static void
addEntryToIcon(MS_Ico const MSIconData,
const char * const xorPpmFname,
const char * const andPgmFname,
bool const trueTransparent) {
IC_Entry entry;
FILE * xorfile;
pixel ** xorPPMarray;
gray ** andPGMarray;
ICON_bmp xorBitmap;
ICON_bmp andBitmap;
int rows, cols;
int bpp, colors;
int entry_cols;
IC_Palette palette;
colorhash_table xorCht;
colorhash_table andCht;
const char * error;
pixval xorMaxval;
gray andMaxval;
MALLOCVAR_NOFAIL(entry);
/*
* Read the xor PPM.
*/
xorfile = pm_openr(xorPpmFname);
xorPPMarray = ppm_readppm(xorfile, &cols, &rows, &xorMaxval);
pm_close(xorfile);
/*
* Since the entry uses 1 byte to hold the width and height of the icon, the
* image can't be more than 256 x 256.
*/
if (rows > 255 || cols > 255) {
pm_error("Max size for a icon is 255 x 255 (1 byte fields). "
"%s is %d x %d", xorPpmFname, cols, rows);
}
if (verbose) pm_message("read PPM: %dw x %dh, maxval = %d",
cols, rows, xorMaxval);
makePalette(xorPPMarray, cols, rows, xorMaxval,
&palette, &xorCht, &colors, &error);
if (error)
pm_error("Unable to make palette for '%s'. %s", xorPpmFname, error);
/*
* All the icons I found seemed to pad the palette to the max entries
* for that bitdepth.
*
* The spec indicates this isn't neccessary, but I'll follow this behaviour
* just in case.
*/
if (colors < 3) {
bpp = 1;
entry_cols = 2;
} else if (colors < 17) {
bpp = 4;
entry_cols = 16;
} else {
bpp = 8;
entry_cols = 256;
}
getOrFakeAndMap(andPgmFname, cols, rows,
&andPGMarray, &andMaxval, &andCht, &error);
if (error)
pm_error("Error in and map for '%s'. %s", xorPpmFname, error);
if (andPGMarray && trueTransparent)
blackenTransparentAreas(xorPPMarray, cols, rows,
andPGMarray, andMaxval);
xorBitmap = createBitmap(bpp, xorPPMarray, cols, rows, xorCht);
andBitmap = createAndBitmap(andPGMarray, cols, rows, andMaxval);
/*
* Fill in the entry data fields.
*/
entry->width = cols;
entry->height = rows;
entry->color_count = entry_cols;
entry->reserved = 0;
entry->planes = 1;
/*
* all the icons I looked at ignored this value...
*/
entry->bitcount = bpp;
entry->ih = createInfoHeader(entry, xorBitmap, andBitmap);
entry->colors = palette->colors;
overflow2(4, entry->color_count);
overflow_add(xorBitmap->size, andBitmap->size);
overflow_add(xorBitmap->size + andBitmap->size, 40);
overflow_add(xorBitmap->size + andBitmap->size + 40, 4 * entry->color_count);
entry->size_in_bytes =
xorBitmap->size + andBitmap->size + 40 + (4 * entry->color_count);
if (verbose)
pm_message("entry->size_in_bytes = %d + %d + %d = %d",
xorBitmap->size ,andBitmap->size,
40, entry->size_in_bytes );
/*
* We don't know the offset ATM, set to 0 for now.
* Have to calculate this at the end.
*/
entry->file_offset = 0;
entry->xorBitmapOut = xorBitmap->data;
entry->andBitmapOut = andBitmap->data;
entry->xBytesXor = xorBitmap->xBytes;
entry->xBytesAnd = andBitmap->xBytes;
/*
* Add the entry to the entries array.
*/
overflow_add(MSIconData->count,1);
MSIconData->count++;
/*
* Perhaps I should use something that allocs a decent amount at start...
*/
MSIconData->entries =
realloc2 (MSIconData->entries, MSIconData->count * sizeof(IC_Entry *));
MSIconData->entries[MSIconData->count-1] = entry;
}
BGD_DECLARE(gdImagePtr) gdImageCreateFromXpm (char *filename)
{
XpmInfo info;
XpmImage image;
int i, j, k, number;
char buf[5];
gdImagePtr im = 0;
int *pointer;
int red = 0, green = 0, blue = 0, alpha = 0;
int *colors;
int ret;
ret = XpmReadFileToXpmImage (filename, &image, &info);
if (ret != XpmSuccess)
return 0;
if (!(im = gdImageCreate (image.width, image.height)))
return 0;
number = image.ncolors;
if (overflow2(sizeof (int), number)) {
return 0;
}
colors = (int *) gdMalloc (sizeof (int) * number);
if (colors == NULL)
return (0);
for (i = 0; i < number; i++)
{
alpha = 0;
switch (strlen (image.colorTable[i].c_color))
{
case 4:
if (!strcasecmp(image.colorTable[i].c_color,"none")) {
red = 0;
green = 0;
blue = 0;
alpha = 127;
} else {
buf[1] = '\0';
buf[0] = image.colorTable[i].c_color[1];
red = strtol (buf, NULL, 16);
buf[0] = image.colorTable[i].c_color[3];
green = strtol (buf, NULL, 16);
buf[0] = image.colorTable[i].c_color[5];
blue = strtol (buf, NULL, 16);
}
break;
case 7:
buf[2] = '\0';
buf[0] = image.colorTable[i].c_color[1];
buf[1] = image.colorTable[i].c_color[2];
red = strtol (buf, NULL, 16);
buf[0] = image.colorTable[i].c_color[3];
buf[1] = image.colorTable[i].c_color[4];
green = strtol (buf, NULL, 16);
buf[0] = image.colorTable[i].c_color[5];
buf[1] = image.colorTable[i].c_color[6];
blue = strtol (buf, NULL, 16);
break;
case 10:
buf[3] = '\0';
buf[0] = image.colorTable[i].c_color[1];
buf[1] = image.colorTable[i].c_color[2];
buf[2] = image.colorTable[i].c_color[3];
red = strtol (buf, NULL, 16);
red /= 64;
buf[0] = image.colorTable[i].c_color[4];
buf[1] = image.colorTable[i].c_color[5];
buf[2] = image.colorTable[i].c_color[6];
green = strtol (buf, NULL, 16);
green /= 64;
buf[0] = image.colorTable[i].c_color[7];
buf[1] = image.colorTable[i].c_color[8];
buf[2] = image.colorTable[i].c_color[9];
blue = strtol (buf, NULL, 16);
blue /= 64;
break;
case 13:
buf[4] = '\0';
buf[0] = image.colorTable[i].c_color[1];
buf[1] = image.colorTable[i].c_color[2];
buf[2] = image.colorTable[i].c_color[3];
buf[3] = image.colorTable[i].c_color[4];
red = strtol (buf, NULL, 16);
red /= 256;
buf[0] = image.colorTable[i].c_color[5];
buf[1] = image.colorTable[i].c_color[6];
buf[2] = image.colorTable[i].c_color[7];
buf[3] = image.colorTable[i].c_color[8];
green = strtol (buf, NULL, 16);
green /= 256;
buf[0] = image.colorTable[i].c_color[9];
buf[1] = image.colorTable[i].c_color[10];
buf[2] = image.colorTable[i].c_color[11];
buf[3] = image.colorTable[i].c_color[12];
blue = strtol (buf, NULL, 16);
blue /= 256;
break;
}
colors[i] = gdImageColorResolveAlpha(im, red, green, blue, alpha);
if (colors[i] == -1)
fprintf (stderr, "ARRRGH\n");
}
pointer = (int *) image.data;
for (i = 0; i < image.height; i++)
{
for (j = 0; j < image.width; j++)
{
k = *pointer++;
gdImageSetPixel (im, j, i, colors[k]);
}
}
gdFree (colors);
return (im);
}
/*! \brief Reads a TGA image data into buffer.
* Reads the image data block from a binary TGA file populating the referenced TGA structure.
* \param ctx Pointer to TGA binary file
* \param tga Pointer to TGA structure
* \return int 0 on sucess, -1 on failure
*/
int read_image_tga( gdIOCtx *ctx, oTga *tga ) {
int pixel_block_size = (tga->bits / 8);
int image_block_size = (tga->width * tga->height) * pixel_block_size;
byte* decompression_buffer = NULL;
unsigned char* conversion_buffer = NULL;
int buffer_caret = 0;
int bitmap_caret = 0;
int i = 0;
int j = 0;
byte encoded_pixels;
if(overflow2(tga->width, tga->height)) {
return -1;
}
if(overflow2(tga->width * tga->height, pixel_block_size)) {
return -1;
}
if(overflow2(image_block_size, sizeof(byte))) {
return -1;
}
/*! \brief Allocate memmory for image block
* Allocate a chunk of memory for the image block to be passed into.
*/
tga->bitmap = (int *) gdMalloc(image_block_size * sizeof(byte));
if (tga->bitmap == NULL) {
return -1;
}
/*! \todo Add image type support
* Add support for this image type.
*/
if (tga->imagetype == TGA_TYPE_INDEXED) {
return -1;
}
/*! \todo Add image type support
* Add support for this image type.
*/
if (tga->imagetype == TGA_TYPE_INDEXED_RLE) {
return -1;
}
/*! \brief Read in uncompressed RGB TGA
* Chunk load the pixel data from an uncompressed RGB type TGA.
*/
if (tga->imagetype == TGA_TYPE_RGB) {
conversion_buffer = (unsigned char *) gdMalloc(image_block_size * sizeof(unsigned char));
if (conversion_buffer == NULL) {
gdFree(conversion_buffer);
return -1;
}
gdGetBuf(conversion_buffer, image_block_size, ctx);
while (buffer_caret < image_block_size) {
tga->bitmap[buffer_caret] = (int) conversion_buffer[buffer_caret];
buffer_caret++;
}
gdFree( conversion_buffer );
}
/*! \brief Read in RLE compressed RGB TGA
* Chunk load the pixel data from an RLE compressed RGB type TGA.
*/
if (tga->imagetype == TGA_TYPE_RGB_RLE) {
decompression_buffer = (byte*) gdMalloc(image_block_size * sizeof(byte));
if (decompression_buffer == NULL) {
gdFree( decompression_buffer );
return -1;
}
conversion_buffer = (unsigned char *) gdMalloc(image_block_size * sizeof(unsigned char));
if (conversion_buffer == NULL) {
gdFree( decompression_buffer );
gdFree( conversion_buffer );
return -1;
}
gdGetBuf( conversion_buffer, image_block_size, ctx );
buffer_caret = 0;
while( buffer_caret < image_block_size ) {
decompression_buffer[buffer_caret] = (int)conversion_buffer[buffer_caret];
buffer_caret++;
}
buffer_caret = 0;
while( bitmap_caret < image_block_size ) {
if ((decompression_buffer[buffer_caret] & TGA_RLE_FLAG) == TGA_RLE_FLAG) {
encoded_pixels = ( ( decompression_buffer[ buffer_caret ] & 127 ) + 1 );
buffer_caret++;
for (i = 0; i < encoded_pixels; i++) {
for (j = 0; j < pixel_block_size; j++, bitmap_caret++) {
tga->bitmap[ bitmap_caret ] = decompression_buffer[ buffer_caret + j ];
}
}
buffer_caret += pixel_block_size;
} else {
encoded_pixels = decompression_buffer[ buffer_caret ] + 1;
buffer_caret++;
for (i = 0; i < encoded_pixels; i++) {
for( j = 0; j < pixel_block_size; j++, bitmap_caret++ ) {
tga->bitmap[ bitmap_caret ] = decompression_buffer[ buffer_caret + j ];
}
buffer_caret += pixel_block_size;
}
}
}
gdFree( decompression_buffer );
gdFree( conversion_buffer );
}
/*! \todo Add image type support
* Add support for this image type.
*/
if( tga->imagetype == TGA_TYPE_GREYSCALE ) {
return -1;
}
/*! \todo Add image type support
* Add support for this image type.
*/
if( tga->imagetype == TGA_TYPE_GREYSCALE_RLE ) {
return -1;
}
return 0;
}
static void
parseCommandLine(int argc, char ** argv,
struct cmdline_info *cmdlineP) {
unsigned int imagewidth_spec, imageheight_spec;
float imagewidth, imageheight;
unsigned int center, nocenter;
unsigned int nosetpage;
float width, height;
unsigned int noturn;
unsigned int showpage, noshowpage;
const char *dpiOpt;
unsigned int dpiSpec;
optStruct3 opt;
unsigned int option_def_index = 0;
optEntry *option_def;
MALLOCARRAY_NOFAIL(option_def, 100);
OPTENT3(0, "scale", OPT_FLOAT, &cmdlineP->scale, NULL, 0);
OPTENT3(0, "dpi", OPT_STRING, &dpiOpt, &dpiSpec, 0);
OPTENT3(0, "width", OPT_FLOAT, &width, NULL, 0);
OPTENT3(0, "height", OPT_FLOAT, &height, NULL, 0);
OPTENT3(0, "psfilter", OPT_FLAG, NULL, &cmdlineP->psfilter, 0);
OPTENT3(0, "turn", OPT_FLAG, NULL, &cmdlineP->mustturn, 0);
OPTENT3(0, "noturn", OPT_FLAG, NULL, ¬urn, 0);
OPTENT3(0, "rle", OPT_FLAG, NULL, &cmdlineP->rle, 0);
OPTENT3(0, "runlength", OPT_FLAG, NULL, &cmdlineP->rle, 0);
OPTENT3(0, "ascii85", OPT_FLAG, NULL, &cmdlineP->ascii85, 0);
OPTENT3(0, "center", OPT_FLAG, NULL, ¢er, 0);
OPTENT3(0, "nocenter", OPT_FLAG, NULL, &nocenter, 0);
OPTENT3(0, "equalpixels", OPT_FLAG, NULL, &cmdlineP->equalpixels, 0);
OPTENT3(0, "imagewidth", OPT_FLOAT, &imagewidth, &imagewidth_spec, 0);
OPTENT3(0, "imageheight", OPT_FLOAT, &imageheight, &imageheight_spec,0);
OPTENT3(0, "nosetpage", OPT_FLAG, NULL, &nosetpage, 0);
OPTENT3(0, "setpage", OPT_FLAG, NULL, &cmdlineP->setpage, 0);
OPTENT3(0, "noshowpage", OPT_FLAG, NULL, &noshowpage, 0);
OPTENT3(0, "flate", OPT_FLAG, NULL, &cmdlineP->flate, 0);
OPTENT3(0, "dict", OPT_FLAG, NULL, &cmdlineP->dict, 0);
OPTENT3(0, "vmreclaim", OPT_FLAG, NULL, &cmdlineP->vmreclaim, 0);
OPTENT3(0, "showpage", OPT_FLAG, NULL, &showpage, 0);
OPTENT3(0, "verbose", OPT_FLAG, NULL, &cmdlineP->verbose, 0);
OPTENT3(0, "level", OPT_UINT, &cmdlineP->level,
&cmdlineP->levelSpec, 0);
/* DEFAULTS */
cmdlineP->scale = 1.0;
width = 8.5;
height = 11.0;
opt.opt_table = option_def;
opt.short_allowed = FALSE;
opt.allowNegNum = FALSE;
optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
if (cmdlineP->mustturn && noturn)
pm_error("You cannot specify both -turn and -noturn");
if (center && nocenter)
pm_error("You cannot specify both -center and -nocenter");
if (showpage && noshowpage)
pm_error("You cannot specify both -showpage and -noshowpage");
if (cmdlineP->setpage && nosetpage)
pm_error("You cannot specify both -setpage and -nosetpage");
if (dpiSpec)
parse_dpi(dpiOpt, &cmdlineP->dpiX, &cmdlineP->dpiY);
else {
cmdlineP->dpiX = 300;
cmdlineP->dpiY = 300;
}
cmdlineP->center = !nocenter;
cmdlineP->canturn = !noturn;
cmdlineP->showpage = !noshowpage;
overflow2(width, 72);
cmdlineP->width = width * 72;
overflow2(width, 72);
cmdlineP->height = height * 72;
if (imagewidth_spec) {
overflow2(imagewidth, 72);
cmdlineP->imagewidth = imagewidth * 72;
}
else
cmdlineP->imagewidth = 0;
if (imageheight_spec) {
overflow2(imagewidth, 72);
cmdlineP->imageheight = imageheight * 72;
} else
cmdlineP->imageheight = 0;
if (!cmdlineP->psfilter &&
(cmdlineP->flate || cmdlineP->ascii85))
pm_error("You must specify -psfilter in order to specify "
"-flate or -ascii85");
if (cmdlineP->rle && cmdlineP->flate)
pm_error("You cannot specify both -rle and -flate");
if (argc-1 == 0)
cmdlineP->input_filespec = "-";
else if (argc-1 != 1)
pm_error("Program takes zero or one argument (filename). You "
"specified %d", argc-1);
else
cmdlineP->input_filespec = argv[1];
}
