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

Include dependency graph for rletotiff.c:

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

#define	USE_PROTOTYPES 1 /* Needs to have a value for tiffcompat.h. */

#define	SETFIELD(tif, fieldname, arg) TIFFSetField(tif,fieldname,arg)

Typedefs
typedef unsigned char	tiff_sample

Functions
void	error (const char *s)

void	get_tiff_scanline (tiff_sample *buf, int row)

void	usage (void)

void	get_scanlines ()

void	main (int argc, argv)

void	error (char *s) const

Variables
static rle_hdr	in_hdr

static rle_pixel **	scan_red

static rle_pixel **	scan_green

static rle_pixel **	scan_blue

static tiff_sample *	RGBscanline

TIFF *	tif

static unsigned short	compression = 5

static int	flip = 0

Macro Definition Documentation

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

Definition at line 10 of file rletotiff.c.

#define SETFIELD	(	tif,
		fieldname,
		arg
	)	TIFFSetField(tif,fieldname,arg)

Definition at line 24 of file rletotiff.c.

#define USE_PROTOTYPES 1 /* Needs to have a value for tiffcompat.h. */

Definition at line 18 of file rletotiff.c.

Typedef Documentation

typedef unsigned char tiff_sample

Definition at line 25 of file rletotiff.c.

Function Documentation

void error ( const char * s )

void error ( char * s ) const

Definition at line 198 of file rletotiff.c.

 {
     fprintf(stderr,"%s: %s\n", in_hdr.cmd, s);
     exit(2);
 }

void get_scanlines ( )

Definition at line 137 of file rletotiff.c.

References flip, in_hdr, rle_hdr::ncolors, rle_getrow(), scan_blue, scan_green, scan_red, rle_hdr::xmax, rle_hdr::ymax, and rle_hdr::ymin.

 {
     int i,j;
     rle_pixel **scan;
 
     scan = (rle_pixel **)malloc( in_hdr.ncolors * sizeof(rle_pixel *) );
     if ( scan == 0 ) error("can't allocate scan");
     scan_red = (rle_pixel**)malloc(sizeof(rle_pixel*)*
                    (in_hdr.ymax-in_hdr.ymin+1));
     scan_green = (rle_pixel**)malloc(sizeof(rle_pixel*)*
                      (in_hdr.ymax-in_hdr.ymin+1));
     scan_blue = (rle_pixel**)malloc(sizeof(rle_pixel*)*
                     (in_hdr.ymax-in_hdr.ymin+1));
     if (!(scan_red && scan_green && scan_blue))
     error("can't allocate a scan buffer");
     if (flip) {
         for (i = 0; i < in_hdr.ymax-in_hdr.ymin+1; i++) {
             for (j=0; j < 3; j++) {
                 scan[j] = (rle_pixel*)malloc(sizeof(rle_pixel)*(in_hdr.xmax+1));
                 if (scan[j] == NULL) error("can't allocate current scanline");
             }
             rle_getrow(&in_hdr, scan);
             scan_red[i] = scan[0];
             scan_green[i] = scan[1];
             scan_blue[i] = scan[2];
             for (j=0; j < 3; j++) {
                 scan[j] = (rle_pixel*)malloc(sizeof(rle_pixel)*(in_hdr.xmax+1));
                 if (scan[j] == NULL) error("can't allocate current scanline");
             }
         }
     } else {
         for (i = 0; i < in_hdr.ymax-in_hdr.ymin+1; i++) {
             for (j=0; j < 3; j++) {
                 scan[j] = (rle_pixel*)malloc(sizeof(rle_pixel)*(in_hdr.xmax+1));
                 if (scan[j] == NULL) error("can't allocate current scanline");
             }
             rle_getrow(&in_hdr, scan);
             scan_red[in_hdr.ymax - in_hdr.ymin - i] = scan[0];
             scan_green[in_hdr.ymax - in_hdr.ymin - i] = scan[1];
             scan_blue[in_hdr.ymax - in_hdr.ymin - i] = scan[2];
         }
     }
     free( scan );
 }

Here is the call graph for this function:

void get_tiff_scanline	(	tiff_sample *	buf,
		int	row
	)

Definition at line 183 of file rletotiff.c.

 {
     register int i;
     register int k;
 
     for (i=k=0; i < in_hdr.xmax+1; i++, k +=3) {
         buf[k] = scan_red[row][i];
         buf[k+1] = scan_green[row][i];
         buf[k+2] = scan_blue[row][i];
     }
 }

void main	(	int	argc,
		argv
	)

Definition at line 52 of file rletotiff.c.

 {
     int i;
     long int rows_per_strip;
     int cflag = 0;
     char *outfname = NULL, *infname = NULL;
 
     in_hdr = *rle_hdr_init( (rle_hdr *)NULL );
 
     if (sizeof(rle_pixel) != sizeof(tiff_sample))
         error("tiff_sample and rle_pixel not same size");
 
     if ( scanargs( argc, argv, "% Cc%- f%- o!-outfile.tiff!s infile.rle%s\n(\
 \tConvert URT image to 24-bit TIFF image.\n\
 \t-c\tUse LZW compression (default)\n\
 \t-C\tUse no compression\n\
 \t-f\tDon't flip image top to bottom\n\
 \t-o outfile.tiff is required)",
            &cflag, &flip, &i, &outfname, &infname ) == 0 )
     exit( 1 );
 
     if ( cflag == 1 )
     compression = COMPRESSION_LZW;
     else if ( cflag == 2 )
     compression = COMPRESSION_NONE;
 
     rle_names( &in_hdr, cmd_name( argv ), infname, 0 );
     in_hdr.rle_file = rle_open_f(in_hdr.cmd, infname, "r");
     rle_get_setup_ok( &in_hdr, in_hdr.cmd, infname );
 
     in_hdr.xmax -= in_hdr.xmin;
     in_hdr.xmin = 0;
     if (in_hdr.ncolors != 3) error("infile must be 24-bit RGB");
     /* No alpha channel, either. */
     RLE_CLR_BIT( in_hdr, RLE_ALPHA );
     get_scanlines();
 /* rletotiff specific code comes after here */
     RGBscanline = (tiff_sample*)malloc(
             sizeof(tiff_sample)*3*(in_hdr.xmax+1));
     if (RGBscanline == NULL) error("can't allocate RGB scanline");
     tif = TIFFOpen(outfname, "w");
     if (!tif) error("tiffopen ret null");
 #ifndef TIFF2p4
     SETFIELD(tif,TIFFTAG_IMAGEWIDTH, in_hdr.xmax + 1);
     SETFIELD(tif,TIFFTAG_IMAGELENGTH, in_hdr.ymax - in_hdr.ymin + 1);
 #else /* TIFF2p4 */
     SETFIELD(tif,TIFFTAG_IMAGEWIDTH, (unsigned long)(in_hdr.xmax + 1));
     SETFIELD(tif,TIFFTAG_IMAGELENGTH,
          (unsigned long)(in_hdr.ymax - in_hdr.ymin + 1));
 #endif /* TIFF2p4 */
     SETFIELD(tif, TIFFTAG_COMPRESSION, compression);
     rows_per_strip = (long)8*1024/(in_hdr.xmax+1);
     if (rows_per_strip < 1) rows_per_strip = 1L;
     SETFIELD(tif, TIFFTAG_ROWSPERSTRIP, rows_per_strip);
     SETFIELD(tif, TIFFTAG_XRESOLUTION, 1.0);
     SETFIELD(tif, TIFFTAG_YRESOLUTION, 1.0);
     SETFIELD(tif, TIFFTAG_RESOLUTIONUNIT, 1);
     SETFIELD(tif, TIFFTAG_BITSPERSAMPLE, 8);
     SETFIELD(tif, TIFFTAG_SAMPLESPERPIXEL, 3);
     SETFIELD(tif, TIFFTAG_PLANARCONFIG, 1);
     SETFIELD(tif, TIFFTAG_PHOTOMETRIC, 2);
     for (i = 0; i < in_hdr.ymax - in_hdr.ymin + 1; i++) {
         get_tiff_scanline(RGBscanline, i);
         TIFFWriteScanline(tif, RGBscanline, i, 1);
     }
     TIFFClose(tif);
 /* rletotiff specific code comes before here */
     for (i = 0; i < in_hdr.ymax - in_hdr.ymin + 1; i++ ) {
         free(scan_red[i]);
         free(scan_green[i]);
         free(scan_blue[i]);
     }
     free(scan_red);
     free(scan_green);
     free(scan_blue);
 }

void usage ( void )

Definition at line 206 of file rletotiff.c.

 {
     fprintf(stderr,"Usage:\n");
     fprintf(stderr,"\trletotiff [options] infile outfile\n");
     fprintf(stderr,"options:\n");
     fprintf(stderr,"\t-c lzw or -c none (compression, default lzw)\n");
     fprintf(stderr,"\t-v  (vertical flip, default not)\n");
     exit(2);
 }