home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Photo CD Demo 1
/
Demo.bin
/
fbm
/
src
/
tiff2fbm.c
< prev
next >
Wrap
C/C++ Source or Header
|
1990-06-24
|
9KB
|
322 lines
/*****************************************************************
* tiff2fbm.c: FBM Release 1.0 25-Feb-90 Michael Mauldin
*
* Copyright (C) 1989,1990 by Michael Mauldin. Permission is granted
* to use this file in whole or in part for any purpose, educational,
* recreational or commercial, provided that this copyright notice
* is retained unchanged. This software is available to all free of
* charge by anonymous FTP and in the UUNET archives.
*
* tiff2fbm.c:
* Convert a TIFF format image to FBM format. Uses Sam Leffler's
* libtiff.a TIFF image library to read TIFF format. See also,
* fbm2tiff for the opposite conversion.
*
* USAGE
* % tiff2fbm [ -<num> ] foo.tif > foo.fbm
*
* EDITLOG
* LastEditDate = Mon Jun 25 00:18:45 1990 - Michael Mauldin
* LastFileName = /usr2/mlm/src/misc/fbm/tiff2fbm.c
*
* HISTORY
* 25-Jun-90 Michael Mauldin (mlm@cs.cmu.edu) Carnegie Mellon
* Package for Release 1.0
*
* 20-Jun-90 Paul Milazzo (milazzo) at BBN
* Patched for STDC.
*
* 14-Jun-89 Michael Mauldin (mlm) at Carnegie-Mellon University
* Created. Based on tiff2ps by Sam Leffler.
*****************************************************************/
# include <stdio.h>
# include <ctype.h>
# ifdef BYTE
# undef BYTE
# endif
# include <tiff.h>
# include <tiffio.h>
# include "fbm.h"
# ifdef __STDC__
# define FIELD(tif,f) TIFFFieldSet(tif, FIELD_ ## f)
# else
/* The following macro is taken from tiff_print.c */
# define FIELD(tif,f) TIFFFieldSet(tif, FIELD_/**/f)
# endif
# define USAGE "Usage: tiff2fbm [ -<num> ] foo.tif > foo.fbm"
/****************************************************************
* main
****************************************************************/
#ifndef lint
static char *fbmid =
"$FBM tiff2fbm.c <1.0> 25-Jun-90 (C) 1989,1990 by Michael Mauldin, source \
code available free from MLM@CS.CMU.EDU and from UUNET archives$";
#endif
#define howmany(x, y) (((x)+((y)-1))/(y))
main (argc, argv)
char *argv[];
{ FBM image;
int userdir = 1, fw, fh, rowlen, plnlen, clrlen=0, colors=0;
double aspect = 0.0;
char *fname = NULL, *title = NULL, *credits = NULL;
TIFF *tif;
TIFFDirectory *td;
u_char *scanbuf, *tail;
register u_char *pp, *obm, *tmp;
int bitspersample, scanline, samplesperbyte;
register unsigned int mask;
register int shift, nib;
register int poff, k, planes;
int i, j, w, h, dirnum = 0;
/* Get the options */
while (--argc > 0 && (*++argv)[0] == '-')
{ while (*++(*argv))
{ switch (**argv)
{
case 'a': aspect = atof (*argv+1); SKIPARG; break;
case 't': title = *argv+1; SKIPARG; break;
case 'c': credits = *argv+1; SKIPARG; break;
default: if (!isdigit (argv[0][1]))
{ fprintf (stderr, "%s\n", USAGE);
exit (1);
}
else
{ userdir = atoi (*argv+1);
SKIPARG;
}
}
}
}
/* Get name of input file */
if (argc != 1)
{ fprintf (stderr, "%s\n", USAGE);
exit (1);
}
fname = *argv;
/* Clear the memory pointers so alloc_fbm won't be confused */
image.cm = image.bm = (unsigned char *) NULL;
/* Now read in the TIFF format image */
/*------------------------------*/
if ((tif = TIFFOpen(fname, "r")) == NULL)
{ exit (1); }
do
{ ++dirnum;
if (userdir != dirnum) continue;
td = &tif->tif_dir;
bitspersample = td->td_bitspersample;
planes = td->td_samplesperpixel;
if (td->td_planarconfig == PLANARCONFIG_CONTIG)
{ bitspersample *= planes; }
scanline = howmany (bitspersample * td->td_imagewidth, 8);
scanbuf = (u_char *) malloc (scanline);
if (scanbuf == NULL)
{ printf ("No space for scanline buffer\n");
continue;
}
w = td->td_imagewidth;
h = td->td_imagelength;
switch (bitspersample)
{ case 1: samplesperbyte = 8; break;
case 2: samplesperbyte = 4; break;
case 4: samplesperbyte = 2; break;
case 8: samplesperbyte = 1; break;
case 24: samplesperbyte = 1; break;
default: fprintf (stderr, "I can't handle %d bits per sample\n",
bitspersample);
exit (1);
}
/* Now build FBM image header */
if (bitspersample == 1)
{ rowlen = 16 * ((w+15)/16); }
else
{ rowlen = 2 * ((w+1)/2); }
plnlen = rowlen * h;
/* Build header */
image.hdr.title[0] = image.hdr.credits[0] = '\0';
image.hdr.rows = h;
image.hdr.cols = w;
image.hdr.planes = planes;
image.hdr.bits = bitspersample / planes;
image.hdr.physbits = 8;
image.hdr.rowlen = rowlen;
image.hdr.plnlen = plnlen;
colors = FIELD (tif,COLORMAP) ? (1 << td->td_bitspersample) : 0;
image.hdr.clrlen = colors * 3;
/* Determine aspect from X and Y resolution */
if (FIELD (tif,RESOLUTION) && td->td_yresolution != 0)
{ image.hdr.aspect = td->td_xresolution / td->td_yresolution; }
else
{ image.hdr.aspect = 1.0; }
/* Extract Title and Credit information */
if (FIELD (tif,DOCUMENTNAME))
{ strcpy (image.hdr.title, td->td_documentname); }
else if (FIELD (tif,IMAGEDESCRIPTION))
{ strcpy (image.hdr.title, td->td_imagedescription); }
else
{ strcpy (image.hdr.title, fname); }
if (FIELD (tif,ARTIST))
{ strcpy (image.hdr.credits, td->td_artist); }
else if (FIELD (tif,SOFTWARE))
{ strcpy (image.hdr.credits, td->td_software); }
else if (FIELD (tif,MAKE))
{ strcpy (image.hdr.credits, td->td_make);
if (FIELD (tif,MODEL))
{ strcat (image.hdr.credits, ", ");
strcat (image.hdr.credits, td->td_model);
}
}
fprintf (stderr, "Reading \"%s\" [%dx%d], %d bits, directory %d\n",
image.hdr.title, w, h, bitspersample, userdir);
/*----------------------------------------------------------------*/
alloc_fbm (&image);
/* Read colormap: Note TIFF colors are 16 bit, FBM colors 8 bit */
if (FIELD (tif,COLORMAP))
{ for (i=0; i<colors; i++)
{ image.cm[i] = td->td_redcolormap[i] >> 8;
image.cm[i + colors] = td->td_greencolormap[i] >> 8;
image.cm[i + colors + colors] = td->td_bluecolormap[i] >> 8;
}
}
/* Check for multiplane images */
if (td->td_planarconfig == PLANARCONFIG_SEPARATE &&
planes > 1)
{ fprintf (stderr, "Multiplane images (%d) not yet implemented\n",
planes);
exit (1);
}
else
{
/*
* Read single plane images (for RGB color, values are stored in
* successive bytes)
*/
/* Precompute mask and shift parameters */
switch (samplesperbyte)
{ case 8: mask = 0x01; shift = 1; break;
case 4: mask = 0x03; shift = 2; break;
case 2: mask = 0x0f; shift = 4; break;
case 1: mask = 0xff; shift = 8; break;
}
nib = 8 - shift;
fprintf (stderr, "Samples per byte %d, mask %02x, shift %d, planes %d, scanline %d\n",
samplesperbyte, mask, shift, planes, scanline);
/* Each loop does one scan line */
for (j=0; j<h; j++)
{ if (TIFFReadScanline (tif, scanbuf, j, 0) < 0)
{ fprintf (stderr, "Error: only read %d lines\n", j); break; }
/* If 0 is WHITE, then flip all bits in the scanline */
if (td->td_photometric == PHOTOMETRIC_MINISWHITE)
{ for (pp = scanbuf, i=scanline; --i >= 0; pp++)
{ *pp = ~ *pp; }
}
pp = scanbuf;
obm = &image.bm[j * rowlen];
tmp = obm;
tail = obm + w;
if (samplesperbyte > 1)
{ for (; obm < tail; obm++)
{ for (k=0, poff=0; k<planes; k++, poff += plnlen)
{ obm[poff] = (*pp >> nib) & mask;
# ifdef DEBUG
if (j< 10 && (obm-tmp)< 18)
{ fprintf (stderr, "<%2d,%2d> obm[%d] = %d, nib %d, mask %d, pp %08x\n",
(obm-tmp), j, poff, obm[poff], nib, mask, pp);
}
# endif
if ((nib -= shift) < 0) { pp++; nib = 8 - shift; }
}
}
}
else
{ for (; obm < tail; obm++)
{ for (k=0, poff=0; k<planes; k++, poff += plnlen)
{ obm[poff] = *pp++; }
}
}
}
}
} while (TIFFReadDirectory (tif));
/*----------------------------------------------------------------*/
if (tif)
{ TIFFClose (tif); }
/* Check whether an image was read */
if (userdir > dirnum)
{ if (dirnum > 0)
{ fprintf (stderr, "File %s has only %d directories, %d out of range\n",
fname, dirnum, userdir);
}
else
{ fprintf (stderr, "File %s has no directories\n", fname); }
exit (1);
}
/*------------------------------*/
if (aspect != 0.0)
{ fprintf (stderr,
"Overiding aspect ratio read (%1.3lf) with (%1.3lf)\n",
image.hdr.aspect, aspect);
image.hdr.aspect = aspect;
}
if (title)
{ strncpy (image.hdr.title, title, FBM_MAX_TITLE); }
if (credits)
{ strncpy (image.hdr.credits, credits, FBM_MAX_TITLE); }
if (write_bitmap (&image, stdout, FMT_FBM))
{ exit (0); }
exit (1);
}