[wxWidgets.git] / src / tiff / tools / tiffgt.c

/* $Id$ */

/*
 * Copyright (c) 1988-1997 Sam Leffler
 * Copyright (c) 1991-1997 Silicon Graphics, Inc.
 * Copyright (c) 2003, Andrey Kiselev <dron@ak4719.spb.edu>
 *
 * Permission to use, copy, modify, distribute, and sell this software and 
 * its documentation for any purpose is hereby granted without fee, provided
 * that (i) the above copyright notices and this permission notice appear in
 * all copies of the software and related documentation, and (ii) the names of
 * Sam Leffler and Silicon Graphics may not be used in any advertising or
 * publicity relating to the software without the specific, prior written
 * permission of Sam Leffler and Silicon Graphics.
 * 
 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
 * 
 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
 * OF THIS SOFTWARE.
 */

#include "tif_config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#if HAVE_APPLE_OPENGL_FRAMEWORK
# include <OpenGL/gl.h>
# include <GLUT/glut.h>
#else
# include <GL/gl.h>
# include <GL/glut.h>
#endif

#include "tiffio.h"
#include "tiffiop.h"

#ifndef HAVE_GETOPT
extern int getopt(int, char**, char*);
#endif

static  uint32  width = 0, height = 0;          /* window width & height */
static  uint32* raster = NULL;                  /* displayable image */
static TIFFRGBAImage img;
static int      order0 = 0, order;
static uint16   photo0 = (uint16) -1, photo;
static int      stoponerr = 0;                  /* stop on read error */
static int      verbose = 0;
#define TITLE_LENGTH    1024
static char     title[TITLE_LENGTH];            /* window title line */
static uint32   xmax, ymax;
static char**   filelist = NULL;
static int      fileindex;
static int      filenum;
static TIFFErrorHandler oerror;
static TIFFErrorHandler owarning;

static void	cleanup_and_exit(void);
static int	initImage(void);
static int	prevImage(void);
static int	nextImage(void);
static void	setWindowSize(void);
static void	usage(void);
static uint16	photoArg(const char*);
static void	raster_draw(void);
static void	raster_reshape(int, int);
static void	raster_keys(unsigned char, int, int);
static void	raster_special(int, int, int);

extern  char* optarg;
extern  int optind;
static TIFF* tif = NULL;

int
main(int argc, char* argv[])
{
        int c;
        int dirnum = -1;
        uint32 diroff = 0;

        oerror = TIFFSetErrorHandler(NULL);
        owarning = TIFFSetWarningHandler(NULL);
        while ((c = getopt(argc, argv, "d:o:p:eflmsvw?")) != -1)
            switch (c) {
            case 'd':
                dirnum = atoi(optarg);
                break;
            case 'e':
                oerror = TIFFSetErrorHandler(oerror);
                break;
            case 'l':
                order0 = FILLORDER_LSB2MSB;
                break;
            case 'm':
                order0 = FILLORDER_MSB2LSB;
                break;
            case 'o':
                diroff = strtoul(optarg, NULL, 0);
                break;
            case 'p':
                photo0 = photoArg(optarg);
                break;
            case 's':
                stoponerr = 1;
                break;
            case 'w':
                owarning = TIFFSetWarningHandler(owarning);
                break;
            case 'v':
                verbose = 1;
                break;
            case '?':
                usage();
                /*NOTREACHED*/
            }
        filenum = argc - optind;
        if ( filenum < 1)
                usage();

        glutInit(&argc, argv);
        glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);

        /*
         * Get the screen size
         */
        xmax = glutGet(GLUT_SCREEN_WIDTH);
        ymax = glutGet(GLUT_SCREEN_HEIGHT);

        /*
         * Use 90% of the screen size
         */
        xmax = xmax - xmax / 10.0;
        ymax = ymax - ymax / 10.0;

        filelist = (char **) _TIFFmalloc(filenum * sizeof(char*));
        if (!filelist) {
                TIFFError(argv[0], "Can not allocate space for the file list.");
                return 1;
        }
        _TIFFmemcpy(filelist, argv + optind, filenum * sizeof(char*));
        fileindex = -1;
        if (nextImage() < 0) {
                _TIFFfree(filelist);
                return 2;
        }
        /*
         * Set initial directory if user-specified
         * file was opened successfully.
         */
        if (dirnum != -1 && !TIFFSetDirectory(tif, dirnum))
            TIFFError(argv[0], "Error, seeking to directory %d", dirnum);
        if (diroff != 0 && !TIFFSetSubDirectory(tif, diroff))
            TIFFError(argv[0], "Error, setting subdirectory at %#x", diroff);
        order = order0;
        photo = photo0;
	if (initImage() < 0){
                _TIFFfree(filelist);
                return 3;
        }
        /*
         * Create a new window or reconfigure an existing
         * one to suit the image to be displayed.
         */
        glutInitWindowSize(width, height);
        snprintf(title, TITLE_LENGTH - 1, "%s [%u]", filelist[fileindex],
                (unsigned int) TIFFCurrentDirectory(tif));
        glutCreateWindow(title);
        glutDisplayFunc(raster_draw);
        glutReshapeFunc(raster_reshape);
        glutKeyboardFunc(raster_keys);
        glutSpecialFunc(raster_special);
        glutMainLoop();

        cleanup_and_exit();
        return 0;
}

static void 
cleanup_and_exit(void)
{
        TIFFRGBAImageEnd(&img);
        if (filelist != NULL)
                _TIFFfree(filelist);
        if (raster != NULL)
                _TIFFfree(raster);
        if (tif != NULL)
                TIFFClose(tif);
        exit(0);
}

static int
initImage(void)
{
        uint32 w, h;

        if (order)
                TIFFSetField(tif, TIFFTAG_FILLORDER, order);
        if (photo != (uint16) -1)
                TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, photo);
        if (!TIFFRGBAImageBegin(&img, tif, stoponerr, title)) {
                TIFFError(filelist[fileindex], "%s", title);
                TIFFClose(tif);
                tif = NULL;
                return -1;
        }

        /*
         * Setup the image raster as required.
         */
        h = img.height;
        w = img.width;
        if (h > ymax) {
                w = (int)(w * ((float)ymax / h));
                h = ymax;
        }
        if (w > xmax) {
                h = (int)(h * ((float)xmax / w));
                w = xmax;
        }

	if (w != width || h != height) {
		uint32 rastersize =
			_TIFFMultiply32(tif, img.width, img.height, "allocating raster buffer");
		if (raster != NULL)
			_TIFFfree(raster), raster = NULL;
		raster = (uint32*) _TIFFCheckMalloc(tif, rastersize, sizeof (uint32),
						    "allocating raster buffer");
		if (raster == NULL) {
			width = height = 0;
			TIFFError(filelist[fileindex], "No space for raster buffer");
			cleanup_and_exit();
		}
		width = w;
		height = h;
	}
	TIFFRGBAImageGet(&img, raster, img.width, img.height);
#if HOST_BIGENDIAN
	TIFFSwabArrayOfLong(raster,img.width*img.height);
#endif
	return 0;
}

static int
prevImage(void)
{
        if (fileindex > 0)
                fileindex--;
        else if (tif)
                return fileindex;
        if (tif)
                TIFFClose(tif);
        tif = TIFFOpen(filelist[fileindex], "r");
        if (tif == NULL)
                return -1;
        return fileindex;
}

static int
nextImage(void)
{
        if (fileindex < filenum - 1)
                fileindex++;
        else if (tif)
                return fileindex;
        if (tif)
                TIFFClose(tif);
        tif = TIFFOpen(filelist[fileindex], "r");
        if (tif == NULL)
                return -1;
        return fileindex;
}

static void
setWindowSize(void)
{
        glutReshapeWindow(width, height);
}

static void
raster_draw(void)
{
  glDrawPixels(img.width, img.height, GL_RGBA, GL_UNSIGNED_BYTE, (const GLvoid *) raster);
}

static void
raster_reshape(int win_w, int win_h)
{
        GLfloat xratio = (GLfloat)win_w/img.width;
        GLfloat yratio = (GLfloat)win_h/img.height;
        int     ratio = (int)(((xratio > yratio)?xratio:yratio) * 100);

        glPixelZoom(xratio, yratio);
        glViewport(0, 0, win_w, win_h);
        snprintf(title, 1024, "%s [%u] %d%%", filelist[fileindex],
                (unsigned int) TIFFCurrentDirectory(tif), ratio);
        glutSetWindowTitle(title);
}

static void
raster_keys(unsigned char key, int x, int y)
{
        switch (key) {
                case 'b':                       /* photometric MinIsBlack */
                    photo = PHOTOMETRIC_MINISBLACK;
                    initImage();
                    break;
                case 'l':                       /* lsb-to-msb FillOrder */
                    order = FILLORDER_LSB2MSB;
                    initImage();
                    break;
                case 'm':                       /* msb-to-lsb FillOrder */
                    order = FILLORDER_MSB2LSB;
                    initImage();
                    break;
                case 'w':                       /* photometric MinIsWhite */
                    photo = PHOTOMETRIC_MINISWHITE;
                    initImage();
                    break;
                case 'W':                       /* toggle warnings */
                    owarning = TIFFSetWarningHandler(owarning);
                    initImage();
                    break;
                case 'E':                       /* toggle errors */
                    oerror = TIFFSetErrorHandler(oerror);
                    initImage();
                    break;
                case 'z':                       /* reset to defaults */
                case 'Z':
                    order = order0;
                    photo = photo0;
                    if (owarning == NULL)
                        owarning = TIFFSetWarningHandler(NULL);
                    if (oerror == NULL)
                        oerror = TIFFSetErrorHandler(NULL);
                    initImage();
                    break;
                case 'q':                       /* exit */
                case '\033':
                    cleanup_and_exit();
        }
        glutPostRedisplay();
}

static void
raster_special(int key, int x, int y)
{
        switch (key) {
                case GLUT_KEY_PAGE_UP:          /* previous logical image */
                    if (TIFFCurrentDirectory(tif) > 0) {
                            if (TIFFSetDirectory(tif,
                                                 TIFFCurrentDirectory(tif)-1)) {
                                    initImage();
                                    setWindowSize();
                        }
                    } else {
                            TIFFRGBAImageEnd(&img);
                            prevImage();
                            initImage();
                            setWindowSize();
                    }
                break;
                case GLUT_KEY_PAGE_DOWN:        /* next logical image */
                    if (!TIFFLastDirectory(tif)) {
                            if (TIFFReadDirectory(tif)) {
                                    initImage();
                                    setWindowSize();
                            }
                    } else {
                            TIFFRGBAImageEnd(&img);
                            nextImage();
                            initImage();
                            setWindowSize();
                    }
                break;
                case GLUT_KEY_HOME:             /* 1st image in current file */
                        if (TIFFSetDirectory(tif, 0)) {
                                TIFFRGBAImageEnd(&img);
                                initImage();
                                setWindowSize();
                        }
                break;
                case GLUT_KEY_END:              /* last image in current file */
                        TIFFRGBAImageEnd(&img);
                        while (!TIFFLastDirectory(tif))
                                TIFFReadDirectory(tif);
                        initImage();
                        setWindowSize();
                break;
        }
        glutPostRedisplay();
}


char* stuff[] = {
"usage: tiffgt [options] file.tif",
"where options are:",
" -c            use colormap visual",
" -d dirnum     set initial directory (default is 0)",
" -e            enable display of TIFF error messages",
" -l            force lsb-to-msb FillOrder",
" -m            force msb-to-lsb FillOrder",
" -o offset     set initial directory offset",
" -p photo      override photometric interpretation",
" -r            use fullcolor visual",
" -s            stop decoding on first error (default is ignore errors)",
" -v            enable verbose mode",
" -w            enable display of TIFF warning messages",
NULL
};

static void
usage(void)
{
        char buf[BUFSIZ];
        int i;

        setbuf(stderr, buf);
                fprintf(stderr, "%s\n\n", TIFFGetVersion());
        for (i = 0; stuff[i] != NULL; i++)
                fprintf(stderr, "%s\n", stuff[i]);
        exit(-1);
}

static uint16
photoArg(const char* arg)
{
        if (strcmp(arg, "miniswhite") == 0)
            return (PHOTOMETRIC_MINISWHITE);
        else if (strcmp(arg, "minisblack") == 0)
            return (PHOTOMETRIC_MINISBLACK);
        else if (strcmp(arg, "rgb") == 0)
            return (PHOTOMETRIC_RGB);
        else if (strcmp(arg, "palette") == 0)
            return (PHOTOMETRIC_PALETTE);
        else if (strcmp(arg, "mask") == 0)
            return (PHOTOMETRIC_MASK);
        else if (strcmp(arg, "separated") == 0)
            return (PHOTOMETRIC_SEPARATED);
        else if (strcmp(arg, "ycbcr") == 0)
            return (PHOTOMETRIC_YCBCR);
        else if (strcmp(arg, "cielab") == 0)
            return (PHOTOMETRIC_CIELAB);
        else if (strcmp(arg, "logl") == 0)
            return (PHOTOMETRIC_LOGL);
        else if (strcmp(arg, "logluv") == 0)
            return (PHOTOMETRIC_LOGLUV);
        else
            return ((uint16) -1);
}

/* vim: set ts=8 sts=8 sw=8 noet: */
/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 8
 * fill-column: 78
 * End:
 */
Commit	Line	Data
8414a40c VZ	1	/* $Id$ */
	2
	3	/*
	4	* Copyright (c) 1988-1997 Sam Leffler
	5	* Copyright (c) 1991-1997 Silicon Graphics, Inc.
	6	* Copyright (c) 2003, Andrey Kiselev <dron@ak4719.spb.edu>
	7	*
	8	* Permission to use, copy, modify, distribute, and sell this software and
	9	* its documentation for any purpose is hereby granted without fee, provided
	10	* that (i) the above copyright notices and this permission notice appear in
	11	* all copies of the software and related documentation, and (ii) the names of
	12	* Sam Leffler and Silicon Graphics may not be used in any advertising or
	13	* publicity relating to the software without the specific, prior written
	14	* permission of Sam Leffler and Silicon Graphics.
	15	*
	16	* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
	17	* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
	18	* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
	19	*
	20	* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
	21	* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
	22	* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
	23	* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
	24	* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
	25	* OF THIS SOFTWARE.
	26	*/
	27
	28	#include "tif_config.h"
	29	#include <stdio.h>
	30	#include <stdlib.h>
	31	#include <string.h>
	32	#include <unistd.h>
	33
	34	#if HAVE_APPLE_OPENGL_FRAMEWORK
	35	# include <OpenGL/gl.h>
	36	# include <GLUT/glut.h>
	37	#else
	38	# include <GL/gl.h>
	39	# include <GL/glut.h>
	40	#endif
	41
	42	#include "tiffio.h"
80ed523f	43	#include "tiffiop.h"
8414a40c VZ	44
	45	#ifndef HAVE_GETOPT
	46	extern int getopt(int, char*, char);
	47	#endif
	48
	49	static uint32 width = 0, height = 0; /* window width & height */
	50	static uint32* raster = NULL; /* displayable image */
	51	static TIFFRGBAImage img;
	52	static int order0 = 0, order;
	53	static uint16 photo0 = (uint16) -1, photo;
	54	static int stoponerr = 0; /* stop on read error */
	55	static int verbose = 0;
	56	#define TITLE_LENGTH 1024
	57	static char title[TITLE_LENGTH]; /* window title line */
	58	static uint32 xmax, ymax;
	59	static char** filelist = NULL;
	60	static int fileindex;
	61	static int filenum;
	62	static TIFFErrorHandler oerror;
	63	static TIFFErrorHandler owarning;
	64
	65	static void cleanup_and_exit(void);
	66	static int initImage(void);
	67	static int prevImage(void);
	68	static int nextImage(void);
	69	static void setWindowSize(void);
	70	static void usage(void);
	71	static uint16 photoArg(const char*);
	72	static void raster_draw(void);
	73	static void raster_reshape(int, int);
	74	static void raster_keys(unsigned char, int, int);
	75	static void raster_special(int, int, int);
	76
	77	extern char* optarg;
	78	extern int optind;
	79	static TIFF* tif = NULL;
	80
	81	int
	82	main(int argc, char* argv[])
	83	{
	84	int c;
	85	int dirnum = -1;
	86	uint32 diroff = 0;
	87
	88	oerror = TIFFSetErrorHandler(NULL);
	89	owarning = TIFFSetWarningHandler(NULL);
	90	while ((c = getopt(argc, argv, "d:o:p:eflmsvw?")) != -1)
	91	switch (c) {
	92	case 'd':
	93	dirnum = atoi(optarg);
	94	break;
	95	case 'e':
	96	oerror = TIFFSetErrorHandler(oerror);
	97	break;
	98	case 'l':
	99	order0 = FILLORDER_LSB2MSB;
	100	break;
	101	case 'm':
	102	order0 = FILLORDER_MSB2LSB;
	103	break;
	104	case 'o':
	105	diroff = strtoul(optarg, NULL, 0);
	106	break;
	107	case 'p':
108	photo0 = photoArg(optarg);
109	break;
110	case 's':
111	stoponerr = 1;
112	break;
113	case 'w':
114	owarning = TIFFSetWarningHandler(owarning);
115	break;
116	case 'v':
117	verbose = 1;
118	break;
119	case '?':
120	usage();
121	/NOTREACHED/
122	}
123	filenum = argc - optind;
124	if ( filenum < 1)
125	usage();
126
127	glutInit(&argc, argv);
128	glutInitDisplayMode(GLUT_SINGLE \| GLUT_RGB);
129
130	/*
131	* Get the screen size
132	*/
133	xmax = glutGet(GLUT_SCREEN_WIDTH);
134	ymax = glutGet(GLUT_SCREEN_HEIGHT);
135
136	/*
137	* Use 90% of the screen size
138	*/
139	xmax = xmax - xmax / 10.0;
140	ymax = ymax - ymax / 10.0;
141
142	filelist = (char *) _TIFFmalloc(filenum sizeof(char*));
143	if (!filelist) {
144	TIFFError(argv[0], "Can not allocate space for the file list.");
145	return 1;
146	}
147	_TIFFmemcpy(filelist, argv + optind, filenum * sizeof(char*));
148	fileindex = -1;
149	if (nextImage() < 0) {
150	_TIFFfree(filelist);
151	return 2;
152	}
153	/*
154	* Set initial directory if user-specified
155	* file was opened successfully.
156	*/
157	if (dirnum != -1 && !TIFFSetDirectory(tif, dirnum))
158	TIFFError(argv[0], "Error, seeking to directory %d", dirnum);
159	if (diroff != 0 && !TIFFSetSubDirectory(tif, diroff))
160	TIFFError(argv[0], "Error, setting subdirectory at %#x", diroff);
161	order = order0;
162	photo = photo0;
163	if (initImage() < 0){
164	_TIFFfree(filelist);
165	return 3;
166	}
167	/*
168	* Create a new window or reconfigure an existing
169	* one to suit the image to be displayed.
170	*/
171	glutInitWindowSize(width, height);
172	snprintf(title, TITLE_LENGTH - 1, "%s [%u]", filelist[fileindex],
173	(unsigned int) TIFFCurrentDirectory(tif));
174	glutCreateWindow(title);
175	glutDisplayFunc(raster_draw);
176	glutReshapeFunc(raster_reshape);
177	glutKeyboardFunc(raster_keys);
178	glutSpecialFunc(raster_special);
179	glutMainLoop();
180
181	cleanup_and_exit();
182	return 0;
183	}
184
185	static void
186	cleanup_and_exit(void)
187	{
188	TIFFRGBAImageEnd(&img);
189	if (filelist != NULL)
190	_TIFFfree(filelist);
191	if (raster != NULL)
192	_TIFFfree(raster);
193	if (tif != NULL)
194	TIFFClose(tif);
195	exit(0);
196	}
197
198	static int
199	initImage(void)
200	{
201	uint32 w, h;
202
203	if (order)
204	TIFFSetField(tif, TIFFTAG_FILLORDER, order);
205	if (photo != (uint16) -1)
206	TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, photo);
207	if (!TIFFRGBAImageBegin(&img, tif, stoponerr, title)) {
80ed523f	208	TIFFError(filelist[fileindex], "%s", title);
8414a40c VZ	209	TIFFClose(tif);
	210	tif = NULL;
	211	return -1;
	212	}
	213
	214	/*
	215	* Setup the image raster as required.
	216	*/
	217	h = img.height;
	218	w = img.width;
	219	if (h > ymax) {
	220	w = (int)(w * ((float)ymax / h));
	221	h = ymax;
	222	}
	223	if (w > xmax) {
	224	h = (int)(h * ((float)xmax / w));
	225	w = xmax;
	226	}
	227
80ed523f VZ	228	if (w != width \|\| h != height) {
	229	uint32 rastersize =
	230	_TIFFMultiply32(tif, img.width, img.height, "allocating raster buffer");
	231	if (raster != NULL)
	232	_TIFFfree(raster), raster = NULL;
	233	raster = (uint32*) _TIFFCheckMalloc(tif, rastersize, sizeof (uint32),
	234	"allocating raster buffer");
	235	if (raster == NULL) {
	236	width = height = 0;
	237	TIFFError(filelist[fileindex], "No space for raster buffer");
	238	cleanup_and_exit();
	239	}
	240	width = w;
	241	height = h;
	242	}
	243	TIFFRGBAImageGet(&img, raster, img.width, img.height);
8414a40c	244	#if HOST_BIGENDIAN
80ed523f	245	TIFFSwabArrayOfLong(raster,img.width*img.height);
8414a40c VZ	246	#endif
	247	return 0;
	248	}
	249
	250	static int
	251	prevImage(void)
	252	{
	253	if (fileindex > 0)
	254	fileindex--;
	255	else if (tif)
	256	return fileindex;
	257	if (tif)
	258	TIFFClose(tif);
	259	tif = TIFFOpen(filelist[fileindex], "r");
	260	if (tif == NULL)
	261	return -1;
	262	return fileindex;
	263	}
	264
	265	static int
	266	nextImage(void)
	267	{
	268	if (fileindex < filenum - 1)
	269	fileindex++;
	270	else if (tif)
	271	return fileindex;
	272	if (tif)
	273	TIFFClose(tif);
	274	tif = TIFFOpen(filelist[fileindex], "r");
	275	if (tif == NULL)
	276	return -1;
	277	return fileindex;
	278	}
	279
	280	static void
	281	setWindowSize(void)
	282	{
	283	glutReshapeWindow(width, height);
	284	}
	285
	286	static void
	287	raster_draw(void)
	288	{
	289	glDrawPixels(img.width, img.height, GL_RGBA, GL_UNSIGNED_BYTE, (const GLvoid *) raster);
	290	}
	291
	292	static void
	293	raster_reshape(int win_w, int win_h)
	294	{
	295	GLfloat xratio = (GLfloat)win_w/img.width;
	296	GLfloat yratio = (GLfloat)win_h/img.height;
	297	int ratio = (int)(((xratio > yratio)?xratio:yratio) * 100);
	298
	299	glPixelZoom(xratio, yratio);
	300	glViewport(0, 0, win_w, win_h);
	301	snprintf(title, 1024, "%s [%u] %d%%", filelist[fileindex],
	302	(unsigned int) TIFFCurrentDirectory(tif), ratio);
	303	glutSetWindowTitle(title);
	304	}
	305
	306	static void
	307	raster_keys(unsigned char key, int x, int y)
	308	{
	309	switch (key) {
310	case 'b': /* photometric MinIsBlack */
311	photo = PHOTOMETRIC_MINISBLACK;
312	initImage();
313	break;
314	case 'l': /* lsb-to-msb FillOrder */
315	order = FILLORDER_LSB2MSB;
316	initImage();
317	break;
318	case 'm': /* msb-to-lsb FillOrder */
319	order = FILLORDER_MSB2LSB;
320	initImage();
321	break;
322	case 'w': /* photometric MinIsWhite */
323	photo = PHOTOMETRIC_MINISWHITE;
324	initImage();
325	break;
326	case 'W': /* toggle warnings */
327	owarning = TIFFSetWarningHandler(owarning);
328	initImage();
329	break;
330	case 'E': /* toggle errors */
331	oerror = TIFFSetErrorHandler(oerror);
332	initImage();
333	break;
334	case 'z': /* reset to defaults */
335	case 'Z':
336	order = order0;
337	photo = photo0;
338	if (owarning == NULL)
339	owarning = TIFFSetWarningHandler(NULL);
340	if (oerror == NULL)
341	oerror = TIFFSetErrorHandler(NULL);
342	initImage();
343	break;
344	case 'q': /* exit */
345	case '\033':
346	cleanup_and_exit();
347	}
348	glutPostRedisplay();
349	}
350
351	static void
352	raster_special(int key, int x, int y)
353	{
354	switch (key) {
355	case GLUT_KEY_PAGE_UP: /* previous logical image */
356	if (TIFFCurrentDirectory(tif) > 0) {
357	if (TIFFSetDirectory(tif,
358	TIFFCurrentDirectory(tif)-1)) {
359	initImage();
360	setWindowSize();
361	}
362	} else {
363	TIFFRGBAImageEnd(&img);
364	prevImage();
365	initImage();
366	setWindowSize();
367	}
368	break;
369	case GLUT_KEY_PAGE_DOWN: /* next logical image */
370	if (!TIFFLastDirectory(tif)) {
371	if (TIFFReadDirectory(tif)) {
372	initImage();
373	setWindowSize();
374	}
375	} else {
376	TIFFRGBAImageEnd(&img);
377	nextImage();
378	initImage();
379	setWindowSize();
380	}
381	break;
382	case GLUT_KEY_HOME: /* 1st image in current file */
383	if (TIFFSetDirectory(tif, 0)) {
384	TIFFRGBAImageEnd(&img);
385	initImage();
386	setWindowSize();
387	}
388	break;
389	case GLUT_KEY_END: /* last image in current file */
390	TIFFRGBAImageEnd(&img);
391	while (!TIFFLastDirectory(tif))
392	TIFFReadDirectory(tif);
393	initImage();
394	setWindowSize();
395	break;
396	}
397	glutPostRedisplay();
398	}
399
400
401
402	char* stuff[] = {
403	"usage: tiffgt [options] file.tif",
404	"where options are:",
405	" -c use colormap visual",
406	" -d dirnum set initial directory (default is 0)",
407	" -e enable display of TIFF error messages",
408	" -l force lsb-to-msb FillOrder",
409	" -m force msb-to-lsb FillOrder",
410	" -o offset set initial directory offset",
411	" -p photo override photometric interpretation",
412	" -r use fullcolor visual",
413	" -s stop decoding on first error (default is ignore errors)",
414	" -v enable verbose mode",
415	" -w enable display of TIFF warning messages",
416	NULL
417	};
418
419	static void
420	usage(void)
421	{
422	char buf[BUFSIZ];
423	int i;
424
425	setbuf(stderr, buf);
426	fprintf(stderr, "%s\n\n", TIFFGetVersion());
427	for (i = 0; stuff[i] != NULL; i++)
428	fprintf(stderr, "%s\n", stuff[i]);
429	exit(-1);
430	}
431
432	static uint16
433	photoArg(const char* arg)
434	{
435	if (strcmp(arg, "miniswhite") == 0)
436	return (PHOTOMETRIC_MINISWHITE);
437	else if (strcmp(arg, "minisblack") == 0)
438	return (PHOTOMETRIC_MINISBLACK);
439	else if (strcmp(arg, "rgb") == 0)
440	return (PHOTOMETRIC_RGB);
441	else if (strcmp(arg, "palette") == 0)
442	return (PHOTOMETRIC_PALETTE);
443	else if (strcmp(arg, "mask") == 0)
444	return (PHOTOMETRIC_MASK);
445	else if (strcmp(arg, "separated") == 0)
446	return (PHOTOMETRIC_SEPARATED);
447	else if (strcmp(arg, "ycbcr") == 0)
448	return (PHOTOMETRIC_YCBCR);
449	else if (strcmp(arg, "cielab") == 0)
450	return (PHOTOMETRIC_CIELAB);
451	else if (strcmp(arg, "logl") == 0)
452	return (PHOTOMETRIC_LOGL);
453	else if (strcmp(arg, "logluv") == 0)
454	return (PHOTOMETRIC_LOGLUV);
455	else
456	return ((uint16) -1);
457	}
458
459	/* vim: set ts=8 sts=8 sw=8 noet: */
80ed523f VZ	460	/*
	461	* Local Variables:
	462	* mode: c
	463	* c-basic-offset: 8
	464	* fill-column: 78
	465	* End:
	466	*/