/*

 * $Id: xtiff.c,v 1.2.2.1 2010-06-08 18:50:40 bfriesen Exp $

 *

 * xtiff - view a TIFF file in an X window

 *

 * Dan Sears

 * Chris Sears

 *

 * Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts.

 *

 *                      All Rights Reserved

 *

 * Permission to use, copy, modify, and distribute this software and its

 * documentation for any purpose and without fee is hereby granted,

 * provided that the above copyright notice appear in all copies and that

 * both that copyright notice and this permission notice appear in

 * supporting documentation, and that the name of Digital not be

 * used in advertising or publicity pertaining to distribution of the

 * software without specific, written prior permission.

 *

 * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING

 * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL

 * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR

 * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,

 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS

 * SOFTWARE.

 *

 * Revision 1.0  90/05/07

 *      Initial release.

 * Revision 2.0  90/12/20

 *      Converted to use the Athena Widgets and the Xt Intrinsics.

 *

 * Notes:

 *

 * According to the TIFF 5.0 Specification, it is possible to have

 * both a TIFFTAG_COLORMAP and a TIFFTAG_COLORRESPONSECURVE.  This

 * doesn't make sense since a TIFFTAG_COLORMAP is 16 bits wide and

 * a TIFFTAG_COLORRESPONSECURVE is tfBitsPerSample bits wide for each

 * channel.  This is probably a bug in the specification.

 * In this case, TIFFTAG_COLORRESPONSECURVE is ignored.

 * This might make sense if TIFFTAG_COLORMAP was 8 bits wide.

 *

 * TIFFTAG_COLORMAP is often incorrectly written as ranging from

 * 0 to 255 rather than from 0 to 65535.  CheckAndCorrectColormap()

 * takes care of this.

 *

 * Only ORIENTATION_TOPLEFT is supported correctly.  This is the

 * default TIFF and X orientation.  Other orientations will be

 * displayed incorrectly.

 *

 * There is no support for or use of 3/3/2 DirectColor visuals.

 * TIFFTAG_MINSAMPLEVALUE and TIFFTAG_MAXSAMPLEVALUE are not supported.

 *

 * Only TIFFTAG_BITSPERSAMPLE values that are 1, 2, 4 or 8 are supported.

 */

#include <math.h>

#include <stdio.h>

#include <stdlib.h>

#include <tiffio.h>

#include <X11/Xatom.h>

#include <X11/Intrinsic.h>

#include <X11/StringDefs.h>

#include <X11/Xproto.h>

#include <X11/Shell.h>

#include <X11/Xaw/Form.h>

#include <X11/Xaw/List.h>

#include <X11/Xaw/Label.h>

#include <X11/cursorfont.h>

#define XK_MISCELLANY

#include <X11/keysymdef.h>

#include "xtifficon.h"

#define TIFF_GAMMA      "2.2"     /* default gamma from the TIFF 5.0 spec */

#define ROUND(x)        (uint16) ((x) + 0.5)

#define SCALE(x, s)     (((x) * 65535L) / (s))

#define MCHECK(m)       if (!m) { fprintf(stderr, "malloc failed\n"); exit(0); }

#define MIN(a, b)       (((a) < (b)) ? (a) : (b))

#define MAX(a, b)       (((a) > (b)) ? (a) : (b))

#define VIEWPORT_WIDTH  700

#define VIEWPORT_HEIGHT 500

#define KEY_TRANSLATE   20

#ifdef __STDC__

#define PP(args)    args

#else

#define PP(args)    ()

#endif

int main PP((int argc, char **argv));

void OpenTIFFFile PP((void));

void GetTIFFHeader PP((void));

void SetNameLabel PP((void));

void CheckAndCorrectColormap PP((void));

void SimpleGammaCorrection PP((void));

void GetVisual PP((void));

Boolean SearchVisualList PP((int image_depth,

    int visual_class, Visual **visual));

void GetTIFFImage PP((void));

void CreateXImage PP((void));

XtCallbackProc SelectProc PP((Widget w, caddr_t unused_1, caddr_t unused_2));

void QuitProc PP((void));

void NextProc PP((void));

void PreviousProc PP((void));

void PageProc PP((int direction));

void EventProc PP((Widget widget, caddr_t unused, XEvent *event));

void ResizeProc PP((void));

int XTiffErrorHandler PP((Display *display, XErrorEvent *error_event));

void Usage PP((void));

int xtVersion = XtSpecificationRelease;     /* xtiff depends on R4 or higher */

/*

 * Xt data structures

 */

Widget shellWidget, formWidget, listWidget, labelWidget, imageWidget;

enum { ButtonQuit = 0, ButtonPreviousPage = 1, ButtonNextPage = 2 };

String buttonStrings[] = { "Quit", "Previous", "Next" };

static XrmOptionDescRec shellOptions[] = {

    { "-help", "*help", XrmoptionNoArg, (caddr_t) "True" },

    { "-gamma", "*gamma", XrmoptionSepArg, NULL },

    { "-usePixmap", "*usePixmap", XrmoptionSepArg, NULL },

    { "-viewportWidth", "*viewportWidth", XrmoptionSepArg, NULL },

    { "-viewportHeight", "*viewportHeight", XrmoptionSepArg, NULL },

    { "-translate", "*translate", XrmoptionSepArg, NULL },

    { "-verbose", "*verbose", XrmoptionSepArg, NULL }

};

typedef struct {

    Boolean help;

    float gamma;

    Boolean usePixmap;

    uint32 viewportWidth;

    uint32 viewportHeight;

    int translate;

    Boolean verbose;

} AppData, *AppDataPtr;

AppData appData;

XtResource clientResources[] = {

    {

        "help", XtCBoolean, XtRBoolean, sizeof(Boolean),

        XtOffset(AppDataPtr, help), XtRImmediate, (XtPointer) False

    }, {

        "gamma", "Gamma", XtRFloat, sizeof(float),

        XtOffset(AppDataPtr, gamma), XtRString, (XtPointer) TIFF_GAMMA

    }, {

        "usePixmap", "UsePixmap", XtRBoolean, sizeof(Boolean),

        XtOffset(AppDataPtr, usePixmap), XtRImmediate, (XtPointer) True

    }, {

        "viewportWidth", "ViewportWidth", XtRInt, sizeof(int),

        XtOffset(AppDataPtr, viewportWidth), XtRImmediate,

        (XtPointer) VIEWPORT_WIDTH

    }, {

        "viewportHeight", "ViewportHeight", XtRInt, sizeof(int),

        XtOffset(AppDataPtr, viewportHeight), XtRImmediate,

        (XtPointer) VIEWPORT_HEIGHT

    }, {

        "translate", "Translate", XtRInt, sizeof(int),

        XtOffset(AppDataPtr, translate), XtRImmediate, (XtPointer) KEY_TRANSLATE

    }, {

        "verbose", "Verbose", XtRBoolean, sizeof(Boolean),

        XtOffset(AppDataPtr, verbose), XtRImmediate, (XtPointer) True

    }

};

Arg formArgs[] = {

    { XtNresizable, True }

};

Arg listArgs[] = {

    { XtNresizable, False },

    { XtNborderWidth, 0 },

    { XtNdefaultColumns, 3 },

    { XtNforceColumns, True },

    { XtNlist, (int) buttonStrings },

    { XtNnumberStrings, XtNumber(buttonStrings) },

    { XtNtop, XtChainTop },

    { XtNleft, XtChainLeft },

    { XtNbottom, XtChainTop },

    { XtNright, XtChainLeft }

};

Arg labelArgs[] = {

    { XtNresizable, False },

    { XtNwidth, 200 },

    { XtNborderWidth, 0 },

    { XtNjustify, XtJustifyLeft },

    { XtNtop, XtChainTop },

    { XtNleft, XtChainLeft },

    { XtNbottom, XtChainTop },

    { XtNright, XtChainLeft }

};

Arg imageArgs[] = {

    { XtNresizable, True },

    { XtNborderWidth, 0 },

    { XtNtop, XtChainTop },

    { XtNleft, XtChainLeft },

    { XtNbottom, XtChainTop },

    { XtNright, XtChainLeft }

};

XtActionsRec actionsTable[] = {

    { "quit", QuitProc },

    { "next", NextProc },

    { "previous", PreviousProc },

    { "notifyresize", ResizeProc }

};

char translationsTable[] = "<Key>q:      quit() \n \

                            <Key>Q:      quit() \n \

                            <Message>WM_PROTOCOLS: quit()\n \

                            <Key>p:      previous() \n \

                            <Key>P:      previous() \n \

                            <Key>n:      next() \n \

                            <Key>N:      next() \n \

                            <Configure>: notifyresize()";

/*

 * X data structures

 */

Colormap            xColormap;

Display *           xDisplay;

Pixmap              xImagePixmap;

Visual *            xVisual;

XImage *            xImage;

GC                  xWinGc;

int                 xImageDepth, xScreen, xRedMask, xGreenMask, xBlueMask,

                    xOffset = 0, yOffset = 0, grabX = -1, grabY = -1;

unsigned char       basePixel = 0;

/*

 * TIFF data structures

 */

TIFF *              tfFile = NULL;

uint32              tfImageWidth, tfImageHeight;

uint16              tfBitsPerSample, tfSamplesPerPixel, tfPlanarConfiguration,

                    tfPhotometricInterpretation, tfGrayResponseUnit,

                    tfImageDepth, tfBytesPerRow;

int                 tfDirectory = 0, tfMultiPage = False;

double              tfUnitMap, tfGrayResponseUnitMap[] = {

                        -1, -10, -100, -1000, -10000, -100000

                    };

/*

 * display data structures

 */

double              *dRed, *dGreen, *dBlue;

/*

 * shared data structures

 */

uint16 *            redMap = NULL, *greenMap = NULL, *blueMap = NULL,

                    *grayMap = NULL, colormapSize;

char *             imageMemory;

char *              fileName;

int

main(int argc, char **argv)

{

    XSetWindowAttributes window_attributes;

    Widget widget_list[3];

    Arg args[5];

    setbuf(stdout, NULL); setbuf(stderr, NULL);

    shellWidget = XtInitialize(argv[0], "XTiff", shellOptions,

        XtNumber(shellOptions), &argc, argv);

    XSetErrorHandler(XTiffErrorHandler);

    XtGetApplicationResources(shellWidget, &appData,

        (XtResourceList) clientResources, (Cardinal) XtNumber(clientResources),

        (ArgList) NULL, (Cardinal) 0);

    if ((argc <= 1) || (argc > 2) || appData.help)

        Usage();

    if (appData.verbose == False) {

        TIFFSetErrorHandler(0);

        TIFFSetWarningHandler(0);

    }

    fileName = argv[1];

    xDisplay = XtDisplay(shellWidget);

    xScreen = DefaultScreen(xDisplay);

    OpenTIFFFile();

    GetTIFFHeader();

    SimpleGammaCorrection();

    GetVisual();

    GetTIFFImage();

    /*

     * Send visual, colormap, depth and iconPixmap to shellWidget.

     * Sending the visual to the shell is only possible with the advent of R4.

     */

    XtSetArg(args[0], XtNvisual, xVisual);

    XtSetArg(args[1], XtNcolormap, xColormap);

    XtSetArg(args[2], XtNdepth,

        xImageDepth == 1 ? DefaultDepth(xDisplay, xScreen) : xImageDepth);

    XtSetArg(args[3], XtNiconPixmap,

        XCreateBitmapFromData(xDisplay, RootWindow(xDisplay, xScreen),

            xtifficon_bits, xtifficon_width, xtifficon_height));

    XtSetArg(args[4], XtNallowShellResize, True);

    XtSetValues(shellWidget, args, 5);

    /*

     * widget instance hierarchy

     */

    formWidget = XtCreateManagedWidget("form", formWidgetClass,

        shellWidget, formArgs, XtNumber(formArgs));

        widget_list[0] = listWidget = XtCreateWidget("list",

            listWidgetClass, formWidget, listArgs, XtNumber(listArgs));

        widget_list[1] = labelWidget = XtCreateWidget("label",

            labelWidgetClass, formWidget, labelArgs, XtNumber(labelArgs));

        widget_list[2] = imageWidget = XtCreateWidget("image",

            widgetClass, formWidget, imageArgs, XtNumber(imageArgs));

    XtManageChildren(widget_list, XtNumber(widget_list));

    /*

     * initial widget sizes - for small images let xtiff size itself

     */

    if (tfImageWidth >= appData.viewportWidth) {

        XtSetArg(args[0], XtNwidth, appData.viewportWidth);

        XtSetValues(shellWidget, args, 1);

    }

    if (tfImageHeight >= appData.viewportHeight) {

        XtSetArg(args[0], XtNheight, appData.viewportHeight);

        XtSetValues(shellWidget, args, 1);

    }

    XtSetArg(args[0], XtNwidth, tfImageWidth);

    XtSetArg(args[1], XtNheight, tfImageHeight);

    XtSetValues(imageWidget, args, 2);

    /*

     * formWidget uses these constraints but they are stored in the children.

     */

    XtSetArg(args[0], XtNfromVert, listWidget);

    XtSetValues(imageWidget, args, 1);

    XtSetArg(args[0], XtNfromHoriz, listWidget);

    XtSetValues(labelWidget, args, 1);

    SetNameLabel();

    XtAddCallback(listWidget, XtNcallback, (XtCallbackProc) SelectProc,

        (XtPointer) NULL);

    XtAddActions(actionsTable, XtNumber(actionsTable));

    XtSetArg(args[0], XtNtranslations,

        XtParseTranslationTable(translationsTable));

    XtSetValues(formWidget, &args[0], 1);

    XtSetValues(imageWidget, &args[0], 1);

    /*

     * This is intended to be a little faster than going through

     * the translation manager.

     */

    XtAddEventHandler(imageWidget, ExposureMask | ButtonPressMask

        | ButtonReleaseMask | Button1MotionMask | KeyPressMask,

        False, EventProc, NULL);

    XtRealizeWidget(shellWidget);

    window_attributes.cursor = XCreateFontCursor(xDisplay, XC_fleur);

    XChangeWindowAttributes(xDisplay, XtWindow(imageWidget),

        CWCursor, &window_attributes);

    CreateXImage();

    XtMainLoop();

    return 0;

}

void

OpenTIFFFile()

{

    if (tfFile != NULL)

        TIFFClose(tfFile);

    if ((tfFile = TIFFOpen(fileName, "r")) == NULL) {

	fprintf(appData.verbose ? stderr : stdout,

	    "xtiff: can't open %s as a TIFF file\n", fileName);

        exit(0);

    }

    tfMultiPage = (TIFFLastDirectory(tfFile) ? False : True);

}

void

GetTIFFHeader()

{

    register int i;

    if (!TIFFSetDirectory(tfFile, tfDirectory)) {

        fprintf(stderr, "xtiff: can't seek to directory %d in %s\n",

            tfDirectory, fileName);

        exit(0);

    }

    TIFFGetField(tfFile, TIFFTAG_IMAGEWIDTH, &tfImageWidth);

    TIFFGetField(tfFile, TIFFTAG_IMAGELENGTH, &tfImageHeight);

    /*

     * If the following tags aren't present then use the TIFF defaults.

     */

    TIFFGetFieldDefaulted(tfFile, TIFFTAG_BITSPERSAMPLE, &tfBitsPerSample);

    TIFFGetFieldDefaulted(tfFile, TIFFTAG_SAMPLESPERPIXEL, &tfSamplesPerPixel);

    TIFFGetFieldDefaulted(tfFile, TIFFTAG_PLANARCONFIG, &tfPlanarConfiguration);

    TIFFGetFieldDefaulted(tfFile, TIFFTAG_GRAYRESPONSEUNIT, &tfGrayResponseUnit);

    tfUnitMap = tfGrayResponseUnitMap[tfGrayResponseUnit];

    colormapSize = 1 << tfBitsPerSample;

    tfImageDepth = tfBitsPerSample * tfSamplesPerPixel;

    dRed = (double *) malloc(colormapSize * sizeof(double));

    dGreen = (double *) malloc(colormapSize * sizeof(double));

    dBlue = (double *) malloc(colormapSize * sizeof(double));

    MCHECK(dRed); MCHECK(dGreen); MCHECK(dBlue);

    /*

     * If TIFFTAG_PHOTOMETRIC is not present then assign a reasonable default.

     * The TIFF 5.0 specification doesn't give a default.

     */

    if (!TIFFGetField(tfFile, TIFFTAG_PHOTOMETRIC,

            &tfPhotometricInterpretation)) {

        if (tfSamplesPerPixel != 1)

            tfPhotometricInterpretation = PHOTOMETRIC_RGB;

        else if (tfBitsPerSample == 1)

            tfPhotometricInterpretation = PHOTOMETRIC_MINISBLACK;

        else if (TIFFGetField(tfFile, TIFFTAG_COLORMAP,

                &redMap, &greenMap, &blueMap)) {

            tfPhotometricInterpretation = PHOTOMETRIC_PALETTE;

            redMap = greenMap = blueMap = NULL;

        } else

            tfPhotometricInterpretation = PHOTOMETRIC_MINISBLACK;

    }

    /*

     * Given TIFFTAG_PHOTOMETRIC extract or create the response curves.

     */

    switch (tfPhotometricInterpretation) {

    case PHOTOMETRIC_RGB:

	redMap = (uint16 *) malloc(colormapSize * sizeof(uint16));

	greenMap = (uint16 *) malloc(colormapSize * sizeof(uint16));

	blueMap = (uint16 *) malloc(colormapSize * sizeof(uint16));

	MCHECK(redMap); MCHECK(greenMap); MCHECK(blueMap);

	for (i = 0; i < colormapSize; i++)

	    dRed[i] = dGreen[i] = dBlue[i]

		= (double) SCALE(i, colormapSize - 1);

        break;

    case PHOTOMETRIC_PALETTE:

        if (!TIFFGetField(tfFile, TIFFTAG_COLORMAP,

                &redMap, &greenMap, &blueMap)) {

            redMap = (uint16 *) malloc(colormapSize * sizeof(uint16));

            greenMap = (uint16 *) malloc(colormapSize * sizeof(uint16));

            blueMap = (uint16 *) malloc(colormapSize * sizeof(uint16));

            MCHECK(redMap); MCHECK(greenMap); MCHECK(blueMap);

            for (i = 0; i < colormapSize; i++)

                dRed[i] = dGreen[i] = dBlue[i]

                    = (double) SCALE(i, colormapSize - 1);

        } else {

            CheckAndCorrectColormap();

            for (i = 0; i < colormapSize; i++) {

                dRed[i] = (double) redMap[i];

                dGreen[i] = (double) greenMap[i];

                dBlue[i] = (double) blueMap[i];

            }

        }

        break;

    case PHOTOMETRIC_MINISWHITE:

        redMap = (uint16 *) malloc(colormapSize * sizeof(uint16));

        greenMap = (uint16 *) malloc(colormapSize * sizeof(uint16));

        blueMap = (uint16 *) malloc(colormapSize * sizeof(uint16));

        MCHECK(redMap); MCHECK(greenMap); MCHECK(blueMap);

	for (i = 0; i < colormapSize; i++)

	    dRed[i] = dGreen[i] = dBlue[i] = (double)

		 SCALE(colormapSize-1-i, colormapSize-1);

        break;

    case PHOTOMETRIC_MINISBLACK:

        redMap = (uint16 *) malloc(colormapSize * sizeof(uint16));

        greenMap = (uint16 *) malloc(colormapSize * sizeof(uint16));

        blueMap = (uint16 *) malloc(colormapSize * sizeof(uint16));

        MCHECK(redMap); MCHECK(greenMap); MCHECK(blueMap);

	for (i = 0; i < colormapSize; i++)

	    dRed[i] = dGreen[i] = dBlue[i] = (double) SCALE(i, colormapSize-1);

        break;

    default:

        fprintf(stderr,

            "xtiff: can't display photometric interpretation type %d\n",

            tfPhotometricInterpretation);

        exit(0);

    }

}

void

SetNameLabel()

{

    char buffer[BUFSIZ];

    Arg args[1];

    if (tfMultiPage)

        snprintf(buffer, sizeof(buffer), "%s - page %d", fileName, tfDirectory);

    else

        snprintf(buffer, sizeof(buffer), "%s", fileName);

    XtSetArg(args[0], XtNlabel, buffer);

    XtSetValues(labelWidget, args, 1);

}

/*

 * Many programs get TIFF colormaps wrong.  They use 8-bit colormaps instead of

 * 16-bit colormaps.  This function is a heuristic to detect and correct this.

 */

void

CheckAndCorrectColormap()

{

    register int i;

    for (i = 0; i < colormapSize; i++)

        if ((redMap[i] > 255) || (greenMap[i] > 255) || (blueMap[i] > 255))

            return;

    for (i = 0; i < colormapSize; i++) {

        redMap[i] = SCALE(redMap[i], 255);

        greenMap[i] = SCALE(greenMap[i], 255);

        blueMap[i] = SCALE(blueMap[i], 255);

    }

    TIFFWarning(fileName, "Assuming 8-bit colormap");

}

void

SimpleGammaCorrection()

{

    register int i;

    register double i_gamma = 1.0 / appData.gamma;

    for (i = 0; i < colormapSize; i++) {

        if (((tfPhotometricInterpretation == PHOTOMETRIC_MINISWHITE)

            && (i == colormapSize - 1))

            || ((tfPhotometricInterpretation == PHOTOMETRIC_MINISBLACK)

            && (i == 0)))

            redMap[i] = greenMap[i] = blueMap[i] = 0;

        else {

            redMap[i] = ROUND((pow(dRed[i] / 65535.0, i_gamma) * 65535.0));

            greenMap[i] = ROUND((pow(dGreen[i] / 65535.0, i_gamma) * 65535.0));

            blueMap[i] = ROUND((pow(dBlue[i] / 65535.0, i_gamma) * 65535.0));

        }

    }

    free(dRed); free(dGreen); free(dBlue);

}

static char* classNames[] = {

    "StaticGray",

    "GrayScale",

    "StaticColor",

    "PseudoColor",

    "TrueColor",

    "DirectColor"

};

/*

 * Current limitation: the visual is set initially by the first file.

 * It cannot be changed.

 */

void

GetVisual()

{

    XColor *colors = NULL;

    unsigned long *pixels = NULL;

    unsigned long i;

    switch (tfImageDepth) {

    /*

     * X really wants a 32-bit image with the fourth channel unused,

     * but the visual structure thinks it's 24-bit.  bitmap_unit is 32.

     */

    case 32:

    case 24:

        if (SearchVisualList(24, DirectColor, &xVisual) == False) {

            fprintf(stderr, "xtiff: 24-bit DirectColor visual not available\n");

            exit(0);

        }

        colors = (XColor *) malloc(3 * colormapSize * sizeof(XColor));

        MCHECK(colors);

        for (i = 0; i < colormapSize; i++) {

            colors[i].pixel = (i << 16) + (i << 8) + i;

            colors[i].red = redMap[i];

            colors[i].green = greenMap[i];

            colors[i].blue = blueMap[i];

            colors[i].flags = DoRed | DoGreen | DoBlue;

        }

        xColormap = XCreateColormap(xDisplay, RootWindow(xDisplay, xScreen),

            xVisual, AllocAll);

        XStoreColors(xDisplay, xColormap, colors, colormapSize);

        break;

    case 8:

    case 4:

    case 2:

        /*

         * We assume that systems with 24-bit visuals also have 8-bit visuals.

         * We don't promote from 8-bit PseudoColor to 24/32 bit DirectColor.

         */

        switch (tfPhotometricInterpretation) {

        case PHOTOMETRIC_MINISWHITE:

        case PHOTOMETRIC_MINISBLACK:

            if (SearchVisualList((int) tfImageDepth, GrayScale, &xVisual) == True)

                break;

        case PHOTOMETRIC_PALETTE:

            if (SearchVisualList((int) tfImageDepth, PseudoColor, &xVisual) == True)

                break;

        default:

            fprintf(stderr, "xtiff: Unsupported TIFF/X configuration\n");

            exit(0);

        }

        colors = (XColor *) malloc(colormapSize * sizeof(XColor));

        MCHECK(colors);

        for (i = 0; i < colormapSize; i++) {

            colors[i].pixel = i;

            colors[i].red = redMap[i];

            colors[i].green = greenMap[i];

            colors[i].blue = blueMap[i];

            colors[i].flags = DoRed | DoGreen | DoBlue;

        }

        /*

         * xtiff's colormap allocation is private.  It does not attempt

         * to detect whether any existing colormap entries are suitable

         * for its use.  This will cause colormap flashing.  Furthermore,

         * background and foreground are taken from the environment.

         * For example, the foreground color may be red when the visual

         * is GrayScale.  If the colormap is completely populated,

         * Xt will not be able to allocate fg and bg.

         */

        if (tfImageDepth == 8)

            xColormap = XCreateColormap(xDisplay, RootWindow(xDisplay, xScreen),

                xVisual, AllocAll);

        else {

            xColormap = XCreateColormap(xDisplay, RootWindow(xDisplay, xScreen),

                xVisual, AllocNone);

            pixels = (unsigned long *)

                malloc(colormapSize * sizeof(unsigned long));

            MCHECK(pixels);

            (void) XAllocColorCells(xDisplay, xColormap, True,

                NULL, 0, pixels, colormapSize);

            basePixel = (unsigned char) pixels[0];

            free(pixels);

        }

        XStoreColors(xDisplay, xColormap, colors, colormapSize);

        break;

    case 1:

        xImageDepth = 1;

        xVisual = DefaultVisual(xDisplay, xScreen);

        xColormap = DefaultColormap(xDisplay, xScreen);

        break;

    default:

        fprintf(stderr, "xtiff: unsupported image depth %d\n", tfImageDepth);

        exit(0);

    }

    if (appData.verbose == True)

	fprintf(stderr, "%s: Using %d-bit %s visual.\n",

	    fileName, xImageDepth, classNames[xVisual->class]);

    if (colors != NULL)

        free(colors);

    if (grayMap != NULL)

        free(grayMap);

    if (redMap != NULL)

        free(redMap);

    if (greenMap != NULL)

        free(greenMap);

    if (blueMap != NULL)

        free(blueMap);

    colors = NULL; grayMap = redMap = greenMap = blueMap = NULL;

}

/*

 * Search for an appropriate visual.  Promote where necessary.

 * Check to make sure that ENOUGH colormap entries are writeable.

 * basePixel was determined when XAllocColorCells() contiguously

 * allocated enough entries.  basePixel is used below in GetTIFFImage.

 */

Boolean

SearchVisualList(image_depth, visual_class, visual)

    int image_depth, visual_class;

    Visual **visual;

{

    XVisualInfo template_visual, *visual_list, *vl;

    int i, n_visuals;

    template_visual.screen = xScreen;

    vl = visual_list = XGetVisualInfo(xDisplay, VisualScreenMask,

        &template_visual, &n_visuals);

    if (n_visuals == 0) {

        fprintf(stderr, "xtiff: visual list not available\n");

        exit(0);

    }

    for (i = 0; i < n_visuals; vl++, i++) {

        if ((vl->class == visual_class) && (vl->depth >= image_depth)

            && (vl->visual->map_entries >= (1 << vl->depth))) {

            *visual = vl->visual;

            xImageDepth = vl->depth;

            xRedMask = vl->red_mask;

            xGreenMask = vl->green_mask;

            xBlueMask = vl->blue_mask;

            XFree((char *) visual_list);

            return True;

        }

    }

    XFree((char *) visual_list);

    return False;

}

void

GetTIFFImage()

{

    int pixel_map[3], red_shift, green_shift, blue_shift;

    char *scan_line, *output_p, *input_p;

    uint32 i, j;

    uint16 s;

    scan_line = (char *) malloc(tfBytesPerRow = TIFFScanlineSize(tfFile));

    MCHECK(scan_line);

    if ((tfImageDepth == 32) || (tfImageDepth == 24)) {

        output_p = imageMemory = (char *)

            malloc(tfImageWidth * tfImageHeight * 4);

        MCHECK(imageMemory);

        /*

         * Handle different color masks for different frame buffers.

         */

        if (ImageByteOrder(xDisplay) == LSBFirst) { /* DECstation 5000 */

            red_shift = pixel_map[0] = xRedMask == 0xFF000000 ? 3

                : (xRedMask == 0xFF0000 ? 2 : (xRedMask == 0xFF00 ? 1 : 0));

            green_shift = pixel_map[1] = xGreenMask == 0xFF000000 ? 3

                : (xGreenMask == 0xFF0000 ? 2 : (xGreenMask == 0xFF00 ? 1 : 0));

            blue_shift = pixel_map[2] = xBlueMask == 0xFF000000 ? 3

                : (xBlueMask == 0xFF0000 ? 2 : (xBlueMask == 0xFF00 ? 1 : 0));

        } else { /* Ardent */

            red_shift = pixel_map[0] = xRedMask == 0xFF000000 ? 0

                : (xRedMask == 0xFF0000 ? 1 : (xRedMask == 0xFF00 ? 2 : 3));

            green_shift = pixel_map[0] = xGreenMask == 0xFF000000 ? 0

                : (xGreenMask == 0xFF0000 ? 1 : (xGreenMask == 0xFF00 ? 2 : 3));

            blue_shift = pixel_map[0] = xBlueMask == 0xFF000000 ? 0

                : (xBlueMask == 0xFF0000 ? 1 : (xBlueMask == 0xFF00 ? 2 : 3));

        }

        if (tfPlanarConfiguration == PLANARCONFIG_CONTIG) {

            for (i = 0; i < tfImageHeight; i++) {

                if (TIFFReadScanline(tfFile, scan_line, i, 0) < 0)

                    break;

                for (input_p = scan_line, j = 0; j < tfImageWidth; j++) {

                    *(output_p + red_shift) = *input_p++;

                    *(output_p + green_shift) = *input_p++;

                    *(output_p + blue_shift) = *input_p++;

                    output_p += 4;

                    if (tfSamplesPerPixel == 4) /* skip the fourth channel */

                        input_p++;

                }

            }

        } else {

            for (s = 0; s < tfSamplesPerPixel; s++) {

                if (s == 3)             /* skip the fourth channel */

                    continue;

                for (i = 0; i < tfImageHeight; i++) {

                    if (TIFFReadScanline(tfFile, scan_line, i, s) < 0)

                        break;

                    input_p = scan_line;

                    output_p = imageMemory + (i*tfImageWidth*4) + pixel_map[s];

                    for (j = 0; j < tfImageWidth; j++, output_p += 4)

                        *output_p = *input_p++;

                }

            }

        }

    } else {

        if (xImageDepth == tfImageDepth) {

            output_p = imageMemory = (char *)

                malloc(tfBytesPerRow * tfImageHeight);

            MCHECK(imageMemory);

            for (i = 0; i < tfImageHeight; i++, output_p += tfBytesPerRow)

                if (TIFFReadScanline(tfFile, output_p, i, 0) < 0)

                    break;

        } else if ((xImageDepth == 8) && (tfImageDepth == 4)) {

            output_p = imageMemory = (char *)

                malloc(tfBytesPerRow * 2 * tfImageHeight + 2);

            MCHECK(imageMemory);

            /*

             * If a scanline is of odd size the inner loop below will overshoot.

             * This is handled very simply by recalculating the start point at

             * each scanline and padding imageMemory a little at the end.

             */

            for (i = 0; i < tfImageHeight; i++) {

                if (TIFFReadScanline(tfFile, scan_line, i, 0) < 0)

                    break;

                output_p = &imageMemory[i * tfImageWidth];

                input_p = scan_line;

                for (j = 0; j < tfImageWidth; j += 2, input_p++) {

                    *output_p++ = (*input_p >> 4) + basePixel;

                    *output_p++ = (*input_p & 0xf) + basePixel;

                }

            }

        } else if ((xImageDepth == 8) && (tfImageDepth == 2)) {

            output_p = imageMemory = (char *)

                malloc(tfBytesPerRow * 4 * tfImageHeight + 4);

            MCHECK(imageMemory);

            for (i = 0; i < tfImageHeight; i++) {

                if (TIFFReadScanline(tfFile, scan_line, i, 0) < 0)

                    break;

                output_p = &imageMemory[i * tfImageWidth];

                input_p = scan_line;

                for (j = 0; j < tfImageWidth; j += 4, input_p++) {

                    *output_p++ = (*input_p >> 6) + basePixel;

                    *output_p++ = ((*input_p >> 4) & 3) + basePixel;

                    *output_p++ = ((*input_p >> 2) & 3) + basePixel;

                    *output_p++ = (*input_p & 3) + basePixel;

                }

            }

        } else if ((xImageDepth == 4) && (tfImageDepth == 2)) {

            output_p = imageMemory = (char *)

                malloc(tfBytesPerRow * 2 * tfImageHeight + 2);

            MCHECK(imageMemory);

            for (i = 0; i < tfImageHeight; i++) {

                if (TIFFReadScanline(tfFile, scan_line, i, 0) < 0)

                    break;

                output_p = &imageMemory[i * tfBytesPerRow * 2];

                input_p = scan_line;

                for (j = 0; j < tfImageWidth; j += 4, input_p++) {

                    *output_p++ = (((*input_p>>6) << 4)

                        | ((*input_p >> 4) & 3)) + basePixel;

                    *output_p++ = ((((*input_p>>2) & 3) << 4)

                        | (*input_p & 3)) + basePixel;

                }

            }

        } else {

            fprintf(stderr,

                "xtiff: can't handle %d-bit TIFF file on an %d-bit display\n",

                tfImageDepth, xImageDepth);

            exit(0);

        }

    }

    free(scan_line);

}

void

CreateXImage()

{

    XGCValues gc_values;

    GC bitmap_gc;

    xOffset = yOffset = 0;

    grabX = grabY = -1;