#include "rle.h"
#include <math.h>
#include <stdio.h>
#include "tiffio.h"

Include dependency graph for tifftorle.c:

Macros
#define	NO_DECLARE_MALLOC /* tiffcompat.h declares it. */

#define	getpixel

Functions
void	error ()

void	get_scanlines ()

void	main (int argc, argv)

void	error (char *s) const

Variables
static rle_hdr	the_hdr

TIFF *	tif

unsigned char *	tiffbuf

static rle_pixel **	scan_red

static rle_pixel **	scan_green

static rle_pixel **	scan_blue

int	flip = 0

unsigned short	samplesperpixel = 1

unsigned short	bitspersample = 8

unsigned char	bitconvert [16]

unsigned char	bc4 [16]

unsigned char	bc2 [4] = { 0, 0x55, 0xaa, 0xff }

unsigned char	bc1 [2] = { 0, 0xff }

Macro Definition Documentation

#define getpixel

Value:

pix = bitconvert[(tiffbuf[k] >> shift) & mask]; \
		if ( --phase == 0 ) { \
            phase = 8 / bitspersample; \
            shift = 8 - bitspersample; \
            k++; \
        } \
        else \
            shift -= bitspersample;

#define NO_DECLARE_MALLOC /* tiffcompat.h declares it. */

Definition at line 10 of file tifftorle.c.

Function Documentation

void error ( )

void error ( char * s ) const

Definition at line 298 of file tifftorle.c.

 {
     fprintf(stderr,"%s: %s in %s\n", the_hdr.cmd, s,
         TIFFFileName(tif));
     exit(2);
 }

void get_scanlines ( )

Definition at line 222 of file tifftorle.c.

References bitspersample, flip, rle_hdr::ncolors, samplesperpixel, scan_blue, scan_green, scan_red, the_hdr, tif, tiffbuf, rle_hdr::xmax, and rle_hdr::ymax.

 {
     int i,j,k,l,n;
  
     scan_red = (rle_pixel**)malloc(sizeof(rle_pixel*)*(the_hdr.ymax+1));
     if (!scan_red)
         error("can't allocate a scan buffer");
     if (the_hdr.ncolors == 3) {
     scan_green = (rle_pixel**)malloc(sizeof(rle_pixel*)*(the_hdr.ymax+1));
     scan_blue = (rle_pixel**)malloc(sizeof(rle_pixel*)*(the_hdr.ymax+1));
     if (!(scan_green && scan_blue))
         error("can't allocate a scan buffer");
     }
     for (i = 0; i < the_hdr.ymax+1; i++) {
     if ( !flip )
         n = the_hdr.ymax - i;
     else
         n = i;
     TIFFReadScanline(tif, tiffbuf, i, 0);
     scan_red[n] = (unsigned char*)malloc(the_hdr.xmax+1);
     if (!scan_red[n])
         error("can't allocate scan buffer");
     if (the_hdr.ncolors == 3) {
         scan_green[n] = (unsigned char*)malloc(the_hdr.xmax+1);
         scan_blue[n] = (unsigned char*)malloc(the_hdr.xmax+1);
         if (!(scan_green[n] && scan_blue[n]))
         error("can't allocate scan buffer");
     }
     if ( bitspersample == 8 )
     {
         for (k = j = 0; j < the_hdr.xmax+1; k+= samplesperpixel, j++) {
         scan_red[n][j] = tiffbuf[k];
         if (the_hdr.ncolors == 3) {
             scan_green[n][j] = tiffbuf[k+1];
             scan_blue[n][j] = tiffbuf[k+2];
         }
         }
     }
     else
     {
         unsigned char mask = 0xff >> (8 - bitspersample);
         int phase = 8 / bitspersample, shift = 8 - bitspersample;
         unsigned char pix;
 
         for ( k = j = 0; j <= the_hdr.xmax; j++ )
         {
 #define getpixel \
         pix = bitconvert[(tiffbuf[k] >> shift) & mask]; \
         if ( --phase == 0 ) { \
             phase = 8 / bitspersample; \
             shift = 8 - bitspersample; \
             k++; \
         } \
         else \
             shift -= bitspersample;
         getpixel;
         scan_red[n][j] = pix;
         if ( the_hdr.ncolors == 3 )
         {
             getpixel;
             scan_green[n][j] = pix;
             getpixel;
             scan_blue[n][j] = pix;
         }
         /* Skip any other channels (e.g., alpha). */
         for ( l = samplesperpixel - the_hdr.ncolors; l > 0; l-- )
         {
             getpixel;
         }
 #undef getpixel
         }
     }
     }
 }

void main	(	int	argc,
		argv
	)

Definition at line 51 of file tifftorle.c.

 {
 #ifndef TIFF2p4
         unsigned short imagelength, imagewidth;
 #else /* TIFF2p4 */
         unsigned long imagelength, imagewidth;
 #endif /* TIFF2p4 */
     unsigned short photometric, shortval;
     unsigned short planarconfig, matteing;
         int row, i;
         rle_pixel *rows[4];
     char *infname = NULL, *outfname = NULL;
  
     the_hdr = *rle_hdr_init( (rle_hdr *)NULL );
     if ( scanargs( argc, argv, "% o%-outfile.rle!s infile.tiff!s\n(\
 \tConvert TIFF image to URT.)",
                &i, &outfname, &infname ) == 0 )
         exit( 1 );
 
     rle_names( &the_hdr, cmd_name( argv ), outfname, 0 );
 
         tif = TIFFOpen(infname, "rb");
         if (!tif) error("can't open input file");
         the_hdr.rle_file = rle_open_f(cmd_name(argv), outfname, "w");
 
     if (TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &imagewidth) == 0)
         error("TIFFGetField TIFFTAG_IMAGEWIDTH failed!");
     if (TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &imagelength) == 0)
         error("TIFFGetField TIFFTAG_IMAGELENGTH failed!");
     if (TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &samplesperpixel) == 0) 
         error("TIFFGetField TIFFTAG_SAMPLESPERPIXEL failed!");
     if (TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &bitspersample) == 0) 
         error("TIFFGetField TIFFTAG_BITSPERSAMPLE failed!");
         if (TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &photometric) == 0)
         error("TIFFGetField TIFFTAG_PHOTOMETRIC failed!");
     switch ( bitspersample )
     {
     case 4:
         for ( i = 0; i < 16; i++ )
         if ( photometric == PHOTOMETRIC_RGB )
             bitconvert[i] = bc4[i];
         else
             bitconvert[i] = i;
         break;
     case 2:
         for ( i = 0; i < 4; i++ )
         if ( photometric == PHOTOMETRIC_RGB )
             bitconvert[i] = bc2[i];
         else
             bitconvert[i] = i;
         break;
     case 1:
         if ( photometric == PHOTOMETRIC_RGB )
         {
         bitconvert[0] = bc1[0];
         bitconvert[1] = bc1[1];
         }
         else
         {
         bitconvert[0] = 0;
         bitconvert[1] = 1;
         }
         break;
     case 8:
         break;
     default:
         error("Bits per sample not 1, 2, 4, or 8");
         break;
     }
     if (TIFFGetField(tif, TIFFTAG_PLANARCONFIG, &planarconfig ) == 0)
         error("TIFFGetField TIFFTAG_PLANARCONFIG failed!");
     /* Might not be present. */
     (void)TIFFGetField(tif, TIFFTAG_MATTEING, &matteing );
         
     switch ( photometric ) {
     case PHOTOMETRIC_MINISWHITE:
     {
         int size =  1 << bitspersample;
         if ( planarconfig == PLANARCONFIG_SEPARATE && matteing )
         samplesperpixel = 1;
         the_hdr.ncolors =  1;
         the_hdr.ncmap = 1;
         the_hdr.cmaplen = bitspersample;
         the_hdr.cmap = (unsigned short *)malloc((unsigned)size*sizeof(short));
         for (i=0; i<size; i++)
         the_hdr.cmap[i] = 65535L - ((long)i * 65535L)/(size - 1);
         break;
     }
     case PHOTOMETRIC_MINISBLACK:
         {
         int size =  1 << bitspersample;
         if ( planarconfig == PLANARCONFIG_SEPARATE && matteing )
         samplesperpixel = 1;
         the_hdr.ncolors =  1;
         the_hdr.ncmap = 1;
         the_hdr.cmaplen = bitspersample;
         the_hdr.cmap = (unsigned short *)malloc((unsigned)size*sizeof(short));
         for (i=0; i<size; i++)
         the_hdr.cmap[i] = ((long)i * 65535L)/(size - 1);
         break;
     }
     case PHOTOMETRIC_RGB:
         if (planarconfig != PLANARCONFIG_CONTIG)
         error("can't handle separate planar config");
 
         the_hdr.ncolors =  3;
         the_hdr.ncmap = 0;
         the_hdr.cmaplen = 0;
         the_hdr.cmap = 0;
         break;
     case PHOTOMETRIC_PALETTE:   /* Handle Colormap */
         {
         unsigned short  *red, *green, *blue;
         int     size;
 
         size = 1 << bitspersample;
         if ( planarconfig == PLANARCONFIG_SEPARATE && matteing )
         samplesperpixel = 1;
         if (TIFFGetField(tif, TIFFTAG_COLORMAP, &red, &green, &blue)) {
         the_hdr.ncolors =  1;
         the_hdr.ncmap = 3;
         the_hdr.cmaplen = bitspersample;
         the_hdr.cmap = (unsigned short *)malloc((unsigned)
                             (3*size*sizeof(short)) );
         for (i=0; i<size; i++) {
             the_hdr.cmap[i] = red[i];
             the_hdr.cmap[i + size] = green[i];
             the_hdr.cmap[i + 2*size] = blue[i];
         }
         } else error("TIFFGetField TIFFTAG_COLORMAP failed!");
         break;
     }
     default:
         error("tiff file PhotoMetric Interpretation not recognized");
     }
     RLE_SET_BIT(the_hdr, RLE_RED);
     if (the_hdr.ncolors == 3) {
         RLE_SET_BIT(the_hdr, RLE_GREEN);
         RLE_SET_BIT(the_hdr, RLE_BLUE);
     }
 
         the_hdr.bg_color = NULL;
         the_hdr.alpha = 0;
         the_hdr.background = 0;
         the_hdr.xmin = 0;
         the_hdr.xmax = imagewidth - 1;
         the_hdr.ymin = 0;
         the_hdr.ymax = imagelength - 1;
  
     rle_addhist( argv, (rle_hdr *)NULL, &the_hdr );
         rle_put_setup( &the_hdr );
  
         tiffbuf = (unsigned char*)malloc((unsigned)TIFFScanlineSize(tif));
         if (!tiffbuf) error("can't allocate tiff scanline buffer");
 
     get_scanlines();
 
         rows[0] = NULL;
         for ( row = 0; row < the_hdr.ymax + 1; row++) {
         rows[1] = scan_red[row];
         if (the_hdr.ncolors == 3) {
         rows[2] = scan_green[row];
         rows[3] = scan_blue[row];
         }
         rle_putrow(rows+1, the_hdr.xmax+1, &the_hdr);
         }
 }