/* * 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 #include #include #include #include #include #include #include #include #include #include #include #include #define XK_MISCELLANY #include "xtifficon.h" #include #define TIFF_GAMMA "2.2" /* default gamma from the TIFF 5.0 spec */ #define ROUND(x) (uint16_t)((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_t viewportWidth; uint32_t 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[] = "q: quit() \n \ Q: quit() \n \ WM_PROTOCOLS: quit()\n \ p: previous() \n \ P: previous() \n \ n: next() \n \ N: next() \n \ : 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_t tfImageWidth, tfImageHeight; uint16_t 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_t *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_t *)malloc(colormapSize * sizeof(uint16_t)); greenMap = (uint16_t *)malloc(colormapSize * sizeof(uint16_t)); blueMap = (uint16_t *)malloc(colormapSize * sizeof(uint16_t)); 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_t *)malloc(colormapSize * sizeof(uint16_t)); greenMap = (uint16_t *)malloc(colormapSize * sizeof(uint16_t)); blueMap = (uint16_t *)malloc(colormapSize * sizeof(uint16_t)); 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_t *)malloc(colormapSize * sizeof(uint16_t)); greenMap = (uint16_t *)malloc(colormapSize * sizeof(uint16_t)); blueMap = (uint16_t *)malloc(colormapSize * sizeof(uint16_t)); 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_t *)malloc(colormapSize * sizeof(uint16_t)); greenMap = (uint16_t *)malloc(colormapSize * sizeof(uint16_t)); blueMap = (uint16_t *)malloc(colormapSize * sizeof(uint16_t)); 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_t i, j; uint16_t 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; xImage = XCreateImage(xDisplay, xVisual, xImageDepth, xImageDepth == 1 ? XYBitmap : ZPixmap, /* offset */ 0, (char *)imageMemory, tfImageWidth, tfImageHeight, /* bitmap_pad */ 8, /* bytes_per_line */ 0); /* * libtiff converts LSB data into MSB but doesn't change the FillOrder tag. */ if (xImageDepth == 1) xImage->bitmap_bit_order = MSBFirst; if (xImageDepth <= 8) xImage->byte_order = MSBFirst; /* * create an appropriate GC */ gc_values.function = GXcopy; gc_values.plane_mask = AllPlanes; if (tfPhotometricInterpretation == PHOTOMETRIC_MINISBLACK) { gc_values.foreground = XWhitePixel(xDisplay, xScreen); gc_values.background = XBlackPixel(xDisplay, xScreen); } else { gc_values.foreground = XBlackPixel(xDisplay, xScreen); gc_values.background = XWhitePixel(xDisplay, xScreen); } xWinGc = XCreateGC(xDisplay, XtWindow(shellWidget), GCFunction | GCPlaneMask | GCForeground | GCBackground, &gc_values); /* * create the pixmap and load the image */ if (appData.usePixmap == True) { xImagePixmap = XCreatePixmap(xDisplay, RootWindow(xDisplay, xScreen), xImage->width, xImage->height, xImageDepth); /* * According to the O'Reilly X Protocol Reference Manual, page 53, * "A pixmap depth of one is always supported and listed, but windows * of depth one might not be supported." Therefore we create a pixmap * of depth one and use XCopyPlane(). This is idiomatic. */ if (xImageDepth == 1) { /* just pass the bits through */ gc_values.foreground = 1; /* foreground describes set bits */ gc_values.background = 0; /* background describes clear bits */ bitmap_gc = XCreateGC(xDisplay, xImagePixmap, GCForeground | GCBackground, &gc_values); XPutImage(xDisplay, xImagePixmap, bitmap_gc, xImage, 0, 0, 0, 0, xImage->width, xImage->height); } else XPutImage(xDisplay, xImagePixmap, xWinGc, xImage, 0, 0, 0, 0, xImage->width, xImage->height); XDestroyImage(xImage); free(imageMemory); } } XtCallbackProc SelectProc(w, unused_1, unused_2) Widget w; caddr_t unused_1; caddr_t unused_2; { XawListReturnStruct *list_return; list_return = XawListShowCurrent(w); switch (list_return->list_index) { case ButtonQuit: QuitProc(); break; case ButtonPreviousPage: PreviousProc(); break; case ButtonNextPage: NextProc(); break; default: fprintf(stderr, "error in SelectProc\n"); exit(0); } XawListUnhighlight(w); } void QuitProc(void) { exit(0); } void NextProc() { PageProc(ButtonNextPage); } void PreviousProc() { PageProc(ButtonPreviousPage); } void PageProc(direction) int direction; { XEvent fake_event; Arg args[4]; switch (direction) { case ButtonPreviousPage: if (tfDirectory > 0) TIFFSetDirectory(tfFile, --tfDirectory); else return; break; case ButtonNextPage: if (TIFFReadDirectory(tfFile) == True) tfDirectory++; else return; break; default: fprintf(stderr, "error in PageProc\n"); exit(0); } xOffset = yOffset = 0; grabX = grabY = -1; GetTIFFHeader(); SetNameLabel(); GetTIFFImage(); if (appData.usePixmap == True) XFreePixmap(xDisplay, xImagePixmap); else XDestroyImage(xImage); CreateXImage(); /* * Using XtSetValues() to set the widget size causes a resize. * This resize gets propagated up to the parent shell. * In order to disable this visually disconcerting effect, * shell resizing is temporarily disabled. */ XtSetArg(args[0], XtNallowShellResize, False); XtSetValues(shellWidget, args, 1); XtSetArg(args[0], XtNwidth, tfImageWidth); XtSetArg(args[1], XtNheight, tfImageHeight); XtSetValues(imageWidget, args, 2); XtSetArg(args[0], XtNallowShellResize, True); XtSetValues(shellWidget, args, 1); XClearWindow(xDisplay, XtWindow(imageWidget)); fake_event.type = Expose; fake_event.xexpose.x = fake_event.xexpose.y = 0; fake_event.xexpose.width = tfImageWidth; /* the window will clip */ fake_event.xexpose.height = tfImageHeight; EventProc(imageWidget, NULL, &fake_event); } void EventProc(widget, unused, event) Widget widget; caddr_t unused; XEvent *event; { int ih, iw, ww, wh, sx, sy, w, h, dx, dy; Dimension w_width, w_height; XEvent next_event; Arg args[2]; if (event->type == MappingNotify) { XRefreshKeyboardMapping((XMappingEvent *)event); return; } if (!XtIsRealized(widget)) return; if ((event->type == ButtonPress) || (event->type == ButtonRelease)) if (event->xbutton.button != Button1) return; iw = tfImageWidth; /* avoid sign problems */ ih = tfImageHeight; /* * The grabX and grabY variables record where the user grabbed the image. * They also record whether the mouse button is down or not. */ if (event->type == ButtonPress) { grabX = event->xbutton.x; grabY = event->xbutton.y; return; } /* * imageWidget is a Core widget and doesn't get resized. * So we calculate the size of its viewport here. */ XtSetArg(args[0], XtNwidth, &w_width); XtSetArg(args[1], XtNheight, &w_height); XtGetValues(shellWidget, args, 2); ww = w_width; wh = w_height; XtGetValues(listWidget, args, 2); wh -= w_height; switch (event->type) { case Expose: dx = event->xexpose.x; dy = event->xexpose.y; sx = dx + xOffset; sy = dy + yOffset; w = MIN(event->xexpose.width, iw); h = MIN(event->xexpose.height, ih); break; case KeyPress: if ((grabX >= 0) || (grabY >= 0)) /* Mouse button is still down */ return; switch (XLookupKeysym((XKeyEvent *)event, /* KeySyms index */ 0)) { case XK_Up: if (ih < wh) /* Don't scroll if the window fits the image. */ return; sy = yOffset + appData.translate; sy = MIN(ih - wh, sy); if (sy == yOffset) /* Filter redundant stationary refreshes. */ return; yOffset = sy; sx = xOffset; dx = dy = 0; w = ww; h = wh; break; case XK_Down: if (ih < wh) return; sy = yOffset - appData.translate; sy = MAX(sy, 0); if (sy == yOffset) return; yOffset = sy; sx = xOffset; dx = dy = 0; w = ww; h = wh; break; case XK_Left: if (iw < ww) return; sx = xOffset + appData.translate; sx = MIN(iw - ww, sx); if (sx == xOffset) return; xOffset = sx; sy = yOffset; dx = dy = 0; w = ww; h = wh; break; case XK_Right: if (iw < ww) return; sx = xOffset - appData.translate; sx = MAX(sx, 0); if (sx == xOffset) return; xOffset = sx; sy = yOffset; dx = dy = 0; w = ww; h = wh; break; default: return; } break; case MotionNotify: /* * MotionEvent compression. Ignore multiple motion events. * Ignore motion events if the mouse button is up. */ if (XPending(xDisplay)) /* Xlib doesn't flush the output buffer */ if (XtPeekEvent(&next_event)) if (next_event.type == MotionNotify) return; if ((grabX < 0) || (grabY < 0)) return; sx = xOffset + grabX - (int)event->xmotion.x; if (sx >= (iw - ww)) /* clamp x motion but allow y motion */ sx = iw - ww; sx = MAX(sx, 0); sy = yOffset + grabY - (int)event->xmotion.y; if (sy >= (ih - wh)) /* clamp y motion but allow x motion */ sy = ih - wh; sy = MAX(sy, 0); if ((sx == xOffset) && (sy == yOffset)) return; dx = dy = 0; w = ww; h = wh; break; case ButtonRelease: xOffset = xOffset + grabX - (int)event->xbutton.x; xOffset = MIN(iw - ww, xOffset); xOffset = MAX(xOffset, 0); yOffset = yOffset + grabY - (int)event->xbutton.y; yOffset = MIN(ih - wh, yOffset); yOffset = MAX(yOffset, 0); grabX = grabY = -1; default: return; } if (appData.usePixmap == True) { if (xImageDepth == 1) XCopyPlane(xDisplay, xImagePixmap, XtWindow(widget), xWinGc, sx, sy, w, h, dx, dy, 1); else XCopyArea(xDisplay, xImagePixmap, XtWindow(widget), xWinGc, sx, sy, w, h, dx, dy); } else XPutImage(xDisplay, XtWindow(widget), xWinGc, xImage, sx, sy, dx, dy, w, h); } void ResizeProc() { Dimension w_width, w_height; int xo, yo, ww, wh; XEvent fake_event; Arg args[2]; if ((xOffset == 0) && (yOffset == 0)) return; XtSetArg(args[0], XtNwidth, &w_width); XtSetArg(args[1], XtNheight, &w_height); XtGetValues(shellWidget, args, 2); ww = w_width; wh = w_height; XtGetValues(listWidget, args, 2); wh -= w_height; xo = xOffset; yo = yOffset; if ((xOffset + ww) >= tfImageWidth) xOffset = MAX((int)tfImageWidth - ww, 0); if ((yOffset + wh) >= tfImageHeight) yOffset = MAX((int)tfImageHeight - wh, 0); /* * Send an ExposeEvent if the origin changed. * We have to do this because of the use and semantics of bit gravity. */ if ((xo != xOffset) || (yo != yOffset)) { fake_event.type = Expose; fake_event.xexpose.x = fake_event.xexpose.y = 0; fake_event.xexpose.width = tfImageWidth; fake_event.xexpose.height = tfImageHeight; EventProc(imageWidget, NULL, &fake_event); } } int XTiffErrorHandler(display, error_event) Display *display; XErrorEvent *error_event; { char message[80]; /* * Some X servers limit the size of pixmaps. */ if ((error_event->error_code == BadAlloc) && (error_event->request_code == X_CreatePixmap)) fprintf(stderr, "xtiff: requested pixmap too big for display\n"); else { XGetErrorText(display, error_event->error_code, message, 80); fprintf(stderr, "xtiff: error code %s\n", message); } exit(0); } void Usage() { fprintf(stderr, "Usage xtiff: [options] tiff-file\n"); fprintf(stderr, "\tstandard Xt options\n"); fprintf(stderr, "\t[-help]\n"); fprintf(stderr, "\t[-gamma gamma]\n"); fprintf(stderr, "\t[-usePixmap (True | False)]\n"); fprintf(stderr, "\t[-viewportWidth pixels]\n"); fprintf(stderr, "\t[-viewportHeight pixels]\n"); fprintf(stderr, "\t[-translate pixels]\n"); fprintf(stderr, "\t[-verbose (True | False)]\n"); exit(0); }