home *** CD-ROM | disk | FTP | other *** search
/ vsiftp.vmssoftware.com / VSIPUBLIC@vsiftp.vmssoftware.com.tar / FREEWARE / FREEWARE40.ZIP / xv310a / xvxwd.c < prev   
Text File  |  1995-06-12  |  16KB  |  627 lines
  1. /* 
  2.  ** Based on xwdtopnm.c - read and write an X11 or X10 window dump file
  3.  **
  4.  ** Modified heavily by Markus Baur (mbaur@ira.uka.de) for use as a part
  5.  ** of xv-2.21, 12/30/92
  6.  **
  7.  ** Hacked up again to support xv-3.00 and XWDs from 64bit machines 
  8.  ** (e.g. DEC Alphas), 04/10/94
  9.  **
  10.  ** Copyright (C) 1989, 1991 by Jef Poskanzer.
  11.  **
  12.  ** Permission to use, copy, modify, and distribute this software and its
  13.  ** documentation for any purpose and without fee is hereby granted, provided
  14.  ** that the above copyright notice appear in all copies and that both that
  15.  ** copyright notice and this permission notice appear in supporting
  16.  ** documentation.  This software is provided "as is" without express or
  17.  ** implied warranty.
  18.  **
  19.  */
  20.  
  21. #include "xv.h"
  22.  
  23.  
  24. /***************************** x11wd.h *****************************/
  25. #define X11WD_FILE_VERSION 7
  26. typedef struct {
  27.     CARD32 header_size;         /* Size of the entire file header (bytes). */
  28.     CARD32 file_version;        /* X11WD_FILE_VERSION */
  29.     CARD32 pixmap_format;       /* Pixmap format */
  30.     CARD32 pixmap_depth;        /* Pixmap depth */
  31.     CARD32 pixmap_width;        /* Pixmap width */
  32.     CARD32 pixmap_height;       /* Pixmap height */
  33.     CARD32 xoffset;             /* Bitmap x offset */
  34.     CARD32 byte_order;          /* MSBFirst, LSBFirst */
  35.     CARD32 bitmap_unit;         /* Bitmap unit */
  36.     CARD32 bitmap_bit_order;    /* MSBFirst, LSBFirst */
  37.     CARD32 bitmap_pad;          /* Bitmap scanline pad */
  38.     CARD32 bits_per_pixel;      /* Bits per pixel */
  39.     CARD32 bytes_per_line;      /* Bytes per scanline */
  40.     CARD32 visual_class;        /* Class of colormap */
  41.     CARD32 red_mask;            /* Z red mask */
  42.     CARD32 green_mask;          /* Z green mask */
  43.     CARD32 blue_mask;           /* Z blue mask */
  44.     CARD32 bits_per_rgb;        /* Log base 2 of distinct color values */
  45.     CARD32 colormap_entries;    /* Number of entries in colormap */
  46.     CARD32 ncolors;             /* Number of Color structures */
  47.     CARD32 window_width;        /* Window width */
  48.     CARD32 window_height;       /* Window height */
  49.     CARD32 window_x;            /* Window upper left X coordinate */
  50.     CARD32 window_y;            /* Window upper left Y coordinate */
  51.     CARD32 window_bdrwidth;     /* Window border width */
  52. #ifdef WORD64
  53.     CARD32 header_pad;
  54. #endif
  55.   } X11WDFileHeader;
  56.  
  57. typedef struct {
  58.   CARD32 num;
  59.   CARD16 red, green, blue;
  60.   CARD8  flags;                 /* do_red, do_green, do_blue */
  61.   CARD8  pad;
  62.   } X11XColor;
  63.  
  64.  
  65. /*-------------------------------------------------------------------------*/
  66.  
  67. typedef byte pixel;
  68.  
  69. /* local functions */
  70. static int    getinit         PARM((FILE *, int*, int*, int*, CARD32 *, 
  71.                                       CARD32, PICINFO *));
  72. static CARD32 getpixnum       PARM((FILE *));
  73. static int    xwdError        PARM((char *));
  74. static void   xwdWarning      PARM((char *));
  75. static int    bs_short        PARM((int));
  76. static CARD32 bs_long         PARM((CARD32));
  77. static int    readbigshort    PARM((FILE *, CARD16 *));
  78. static int    readbiglong     PARM((FILE *, CARD32 *));
  79. static int    readlittleshort PARM((FILE *, CARD16 *));
  80. static int    readlittlelong  PARM((FILE *, CARD32 *));
  81. static int    writebigshort   PARM((FILE *, int));
  82. static int    writebiglong    PARM((FILE *, CARD32));
  83.  
  84. static byte  *pic8, *pic24;
  85. static CARD32 red_mask, green_mask, blue_mask;
  86. static int    bits_per_item, bits_used, bit_shift, bits_per_pixel;
  87. static char   buf[4];
  88. static char   *byteP;
  89. static CARD16 *shortP;
  90. static CARD32 *longP;
  91. static CARD32 pixel_mask;
  92. static int    byte_swap, byte_order, bit_order, filesize;
  93. static byte   bw[2] = {0, 0xff};
  94.  
  95. static char  *bname;
  96.  
  97.  
  98.  
  99. /*************************************/
  100. int LoadXWD(fname, pinfo)
  101.      char *fname;
  102.      PICINFO *pinfo;
  103. {
  104.   /* returns '1' on success */
  105.  
  106.   pixel *xP;
  107.   int    col;
  108.   int    rows, cols, padright, row;
  109.   CARD32 maxval, visualclass;
  110.   FILE  *ifp;
  111.  
  112.   bname          = BaseName(fname);
  113.   pinfo->pic     = (byte *) NULL;
  114.   pinfo->comment = (char *) NULL;
  115.   maxval         = 0;
  116.  
  117.   ifp = xv_fopen(fname, "r");
  118.   if (!ifp) return (xwdError("can't open file"));
  119.   
  120.   /* figure out the file size (used to check colormap size) */
  121.   fseek(ifp, 0L, 2);
  122.   filesize = ftell(ifp);
  123.   fseek(ifp, 0L, 0);
  124.   
  125.  
  126.   if (getinit(ifp, &cols, &rows, &padright, &visualclass, maxval, pinfo))
  127.     return 0;
  128.  
  129.  
  130.   switch (visualclass) {
  131.   case StaticGray:
  132.   case GrayScale:
  133.     pinfo->colType = F_GREYSCALE;
  134.     pic8 = (byte *) calloc((size_t) cols*rows, (size_t) 1);
  135.     if (!pic8) {
  136.       xwdError("couldn't malloc 'pic'");
  137.       return 0;
  138.     }
  139.  
  140.     for (row=0; row<rows; row++) {
  141.       for (col=0, xP=pic8+(row*cols); col<cols; col++, xP++)
  142.     *xP = getpixnum(ifp);
  143.       
  144.       for (col=0; col<padright; col++) getpixnum(ifp);
  145.     }
  146.  
  147.     pinfo->type = PIC8;
  148.     pinfo->pic  = pic8;
  149.     break;      
  150.  
  151.   case StaticColor:
  152.   case PseudoColor:
  153.     pinfo->colType = F_FULLCOLOR;
  154.     pic8 = (byte *) calloc((size_t) cols*rows, (size_t) 1);
  155.     if (!pic8) {
  156.       xwdError("couldn't malloc 'pic'");
  157.       return 0;
  158.     }
  159.  
  160.     for (row=0; row<rows; row++) {
  161.       for (col=0, xP=pic8+(row*cols); col<cols; col++, xP++)
  162.     *xP = getpixnum(ifp);
  163.       for (col=0; col<padright; col++) getpixnum(ifp);
  164.     }
  165.     
  166.     pinfo->type = PIC8;
  167.     pinfo->pic  = pic8;
  168.     break;      
  169.  
  170.   case TrueColor:
  171.   case DirectColor:
  172.     pinfo->colType = F_FULLCOLOR;
  173.     pic24 = (byte *) calloc((size_t) cols*rows*3, (size_t) 1);
  174.     if (!pic24) {
  175.       xwdError("couldn't malloc 'pic24'");
  176.       return 0;
  177.     }
  178.  
  179.     for (row=0; row<rows; row++) {
  180.       for (col=0, xP=pic24+(row*cols*3); col<cols; col++) {
  181.     CARD32 ul;
  182.     
  183.     ul = getpixnum(ifp);
  184.     switch (bits_per_pixel) {
  185.     case 16:
  186.       *xP++ = ((ul & red_mask)   >> 0);
  187.       *xP++ = ((ul & green_mask) >> 5);
  188.       *xP++ = ((ul & blue_mask)  >> 10);
  189.       break;
  190.       
  191.     case 24:
  192.     case 32:
  193.       *xP++ = (ul    ) & 0xff;
  194.       *xP++ = (ul>> 8) & 0xff;
  195.       *xP++ = (ul>>16) & 0xff;
  196.       break;
  197.       
  198.     default:
  199.       xwdError("True/Direct only supports 16, 24, and 32 bits");
  200.       return 0;
  201.     }
  202.       }
  203.  
  204.       for (col=0; col<padright; col++) getpixnum(ifp);
  205.     }
  206.     
  207.     pinfo->type = PIC24;
  208.     pinfo->pic  = pic24;
  209.     break;
  210.     
  211.   default:
  212.     xwdError("unknown visual class");
  213.     return 0;
  214.   }
  215.  
  216.   sprintf(pinfo->fullInfo, "XWD, %d-bit %s.  (%d bytes)",
  217.       bits_per_pixel, 
  218.       ((visualclass == StaticGray ) ? "StaticGray"  :
  219.        (visualclass == GrayScale  ) ? "GrayScale"   :
  220.        (visualclass == StaticColor) ? "StaticColor" :
  221.        (visualclass == PseudoColor) ? "PseudoColor" :
  222.        (visualclass == TrueColor  ) ? "TrueColor"   :
  223.        (visualclass == DirectColor) ? "DirectColor" : "<unknown>"),
  224.       filesize);
  225.  
  226.   sprintf(pinfo->shrtInfo, "%dx%d XWD.", cols, rows);
  227.  
  228.   pinfo->normw = pinfo->w = cols;
  229.   pinfo->normh = pinfo->h = rows;
  230.  
  231.   fclose(ifp);
  232.   return 1;
  233. }
  234.  
  235.  
  236. /*********************/
  237. static int getinit(file, colsP, rowsP, padrightP, visualclassP, maxv, pinfo)
  238.      FILE* file;
  239.      int* colsP;
  240.      int* rowsP;
  241.      int* padrightP;
  242.      CARD32 * visualclassP;
  243.      CARD32   maxv;
  244.      PICINFO *pinfo;
  245. {
  246.   int              i;
  247.   int              grayscale;
  248.   char             errstr[200];
  249.   byte             header[sizeof(X11WDFileHeader)];
  250.   X11WDFileHeader *h11P;
  251.   X11XColor       *x11colors;
  252.   CARD32           pad;
  253.   int              word64 = 0;
  254.  
  255.   x11colors = (X11XColor *) NULL;
  256.  
  257.   byte_swap = 0;
  258.   maxv = 255L;
  259.  
  260.   h11P = (X11WDFileHeader*) header;
  261.   
  262.   if (fread(&header[0], sizeof(*h11P), (size_t) 1, file) != 1)
  263.     return(xwdError("couldn't read X11 XWD file header"));
  264.   
  265.   if (h11P->file_version != X11WD_FILE_VERSION) {
  266.     byte_swap = 1;
  267.     h11P->header_size      = bs_long(h11P->header_size);
  268.     h11P->file_version     = bs_long(h11P->file_version);
  269.     h11P->pixmap_format    = bs_long(h11P->pixmap_format);
  270.     h11P->pixmap_depth     = bs_long(h11P->pixmap_depth);
  271.     h11P->pixmap_width     = bs_long(h11P->pixmap_width);
  272.     h11P->pixmap_height    = bs_long(h11P->pixmap_height);
  273.     h11P->xoffset          = bs_long(h11P->xoffset);
  274.     h11P->byte_order       = bs_long(h11P->byte_order);
  275.     h11P->bitmap_unit      = bs_long(h11P->bitmap_unit);
  276.     h11P->bitmap_bit_order = bs_long(h11P->bitmap_bit_order);
  277.     h11P->bitmap_pad       = bs_long(h11P->bitmap_pad);
  278.     h11P->bits_per_pixel   = bs_long(h11P->bits_per_pixel);
  279.     h11P->bytes_per_line   = bs_long(h11P->bytes_per_line);
  280.     h11P->visual_class     = bs_long(h11P->visual_class);
  281.     h11P->red_mask         = bs_long(h11P->red_mask);
  282.     h11P->green_mask       = bs_long(h11P->green_mask);
  283.     h11P->blue_mask        = bs_long(h11P->blue_mask);
  284.     h11P->bits_per_rgb     = bs_long(h11P->bits_per_rgb);
  285.     h11P->colormap_entries = bs_long(h11P->colormap_entries);
  286.     h11P->ncolors          = bs_long(h11P->ncolors);
  287.     h11P->window_width     = bs_long(h11P->window_width);
  288.     h11P->window_height    = bs_long(h11P->window_height);
  289.     h11P->window_x         = bs_long(h11P->window_x);
  290.     h11P->window_y         = bs_long(h11P->window_y);
  291.     h11P->window_bdrwidth  = bs_long(h11P->window_bdrwidth);
  292.   }
  293.  
  294.   for (i=0; i<h11P->header_size - sizeof(*h11P); i++)
  295.     if (getc(file) == EOF)
  296.       return(xwdError("couldn't read rest of X11 XWD file header"));
  297.       
  298.   /* Check whether we can handle this dump. */
  299.   if (h11P->pixmap_depth > 24)
  300.     return(xwdError("can't handle X11 pixmap_depth > 24"));
  301.  
  302.   if (h11P->bits_per_rgb > 24)
  303.     return(xwdError("can't handle X11 bits_per_rgb > 24"));
  304.  
  305.   if (h11P->pixmap_format != ZPixmap && h11P->pixmap_depth != 1)  {
  306.     sprintf(errstr, "can't handle X11 pixmap_format %d with depth != 1",
  307.         h11P->pixmap_format);
  308.     return(xwdError(errstr));
  309.   }
  310.  
  311.   if (h11P->bitmap_unit != 8 && h11P->bitmap_unit != 16 &&
  312.       h11P->bitmap_unit != 32)  {
  313.     sprintf(errstr, "X11 bitmap_unit (%d) is non-standard - can't handle",
  314.         h11P->bitmap_unit);
  315.     return(xwdError(errstr));
  316.   }
  317.   
  318.   grayscale = 1;
  319.   if (h11P->ncolors > 0) {      /* Read X11 colormap. */
  320.     x11colors = (X11XColor*) malloc(h11P->ncolors * sizeof(X11XColor));
  321.     if (!x11colors) return(xwdError("out of memory"));
  322.     
  323.     if (h11P->header_size + h11P->ncolors * sizeof(X11XColor) 
  324.     + h11P->pixmap_height * h11P->bytes_per_line + h11P->ncolors * 4
  325.     == filesize ) word64 = 1;
  326.     
  327.     if (word64) {
  328.       for (i = 0; i < h11P->ncolors; ++i) {
  329.     if (fread(&pad, sizeof(pad), (size_t) 1, file ) != 1)
  330.       return(xwdError("couldn't read X11 XWD colormap"));
  331.  
  332.     if (fread( &x11colors[i], sizeof(X11XColor), (size_t) 1, file) != 1)
  333.       return(xwdError("couldn't read X11 XWD colormap"));
  334.       }
  335.     }
  336.     else {
  337.       if (fread(x11colors, sizeof(X11XColor), (size_t) h11P->ncolors, file) 
  338.       != h11P->ncolors)
  339.     return(xwdError("couldn't read X11 XWD colormap"));
  340.     }
  341.     
  342.     for (i = 0; i < h11P->ncolors; ++i) {
  343.       if (byte_swap) {
  344.     x11colors[i].red   = (CARD16) bs_short(x11colors[i].red);
  345.     x11colors[i].green = (CARD16) bs_short(x11colors[i].green);
  346.     x11colors[i].blue  = (CARD16) bs_short(x11colors[i].blue);
  347.       }
  348.  
  349.       if (maxv != 65535L) {
  350.     x11colors[i].red   = (u_short) ((x11colors[i].red   * maxv) / 65535);
  351.     x11colors[i].green = (u_short) ((x11colors[i].green * maxv) / 65535);
  352.     x11colors[i].blue  = (u_short) ((x11colors[i].blue  * maxv) / 65535);
  353.       }
  354.       if (x11colors[i].red != x11colors[i].green ||
  355.       x11colors[i].green != x11colors[i].blue)
  356.     grayscale = 0;
  357.     }
  358.   }
  359.   
  360.   *visualclassP = h11P->visual_class;
  361.   if (*visualclassP == TrueColor || *visualclassP == DirectColor) {
  362.     if (h11P->bits_per_pixel == 16) maxv = 31;
  363.     else maxv = 255;
  364.   }
  365.  
  366.   else if (*visualclassP == StaticGray && h11P->bits_per_pixel == 1) {
  367.     maxv = 1;
  368.     /* B/W bitmaps have a two entry colormap */
  369.     pinfo->r[0] = pinfo->g[0] = pinfo->b[0] = 255;   /* 0 = white */
  370.     pinfo->r[1] = pinfo->g[1] = pinfo->b[1] = 0;     /* 1 = black */
  371.   }
  372.  
  373.   else if (*visualclassP == StaticGray) {
  374.     maxv = (1 << h11P->bits_per_pixel) - 1;
  375.     for (i=0; i<=maxv; i++)
  376.       pinfo->r[i] = pinfo->g[i] = pinfo->b[i] = x11colors[i].red;
  377.   }
  378.  
  379.   else {
  380.     if (grayscale) {
  381.       for (i=0; i<=h11P->ncolors; i++)
  382.     pinfo->r[i] = pinfo->g[i] = pinfo->b[i] = x11colors[i].red;
  383.     }
  384.     else {
  385.       for (i = 0; i < h11P->ncolors; ++i) {
  386.     pinfo->r[i] = x11colors[i].red;
  387.     pinfo->g[i] = x11colors[i].green;
  388.     pinfo->b[i] = x11colors[i].blue;
  389.       }
  390.     }
  391.   }
  392.       
  393.   *colsP = h11P->pixmap_width;
  394.   *rowsP = h11P->pixmap_height;
  395.   *padrightP = h11P->bytes_per_line * 8 / h11P->bits_per_pixel -
  396.     h11P->pixmap_width;
  397.   
  398.   bits_per_item  = h11P->bitmap_unit;
  399.   bits_used      = bits_per_item;
  400.   bits_per_pixel = h11P->bits_per_pixel;
  401.   byte_order     = h11P->byte_order;
  402.   bit_order      = h11P->bitmap_bit_order;
  403.   
  404.   if (bits_per_pixel == sizeof(pixel_mask) * 8)  pixel_mask = (CARD32) -1;
  405.   else pixel_mask = (1 << bits_per_pixel) - 1;
  406.   
  407.   red_mask   = h11P->red_mask;
  408.   green_mask = h11P->green_mask;
  409.   blue_mask  = h11P->blue_mask;
  410.  
  411.   byteP  = (char   *) buf;
  412.   shortP = (CARD16 *) buf;
  413.   longP  = (CARD32 *) buf;
  414.  
  415.   return 0;
  416. }
  417.  
  418.  
  419. /******************************/
  420. static CARD32 getpixnum(file)
  421.      FILE* file;
  422. {
  423.   int n;
  424.   
  425.   if (bits_used == bits_per_item) {
  426.     switch (bits_per_item) {
  427.     case 8:
  428.       *byteP = getc(file);
  429.       break;
  430.       
  431.     case 16:
  432.       if (byte_order == MSBFirst) {
  433.     if (readbigshort(file, shortP) == -1)
  434.       xwdWarning("unexpected EOF");
  435.       }
  436.       else {
  437.     if (readlittleshort(file, shortP) == -1)
  438.       xwdWarning("unexpected EOF");
  439.       }
  440.       break;
  441.       
  442.     case 32:
  443.       if (byte_order == MSBFirst) {
  444.     if (readbiglong(file, longP) == -1)
  445.       xwdWarning("unexpected EOF");
  446.       }
  447.       else {
  448.     if (readlittlelong(file, longP) == -1)
  449.       xwdWarning("unexpected EOF");
  450.       }
  451.       break;
  452.       
  453.     default:
  454.       xwdWarning("can't happen");
  455.     }
  456.     bits_used = 0;
  457.     
  458.     if (bit_order == MSBFirst)
  459.       bit_shift = bits_per_item - bits_per_pixel;
  460.     else
  461.       bit_shift = 0;
  462.   }
  463.   
  464.   switch (bits_per_item) {
  465.   case 8:
  466.     n = (*byteP >> bit_shift) & pixel_mask;
  467.     break;
  468.     
  469.   case 16:
  470.     n = (*shortP >> bit_shift) & pixel_mask;
  471.     break;
  472.     
  473.   case 32:
  474.     n = (*longP >> bit_shift) & pixel_mask;
  475.     break;
  476.     
  477.   default:
  478.     n = 0;
  479.     xwdWarning("can't happen");
  480.   }
  481.   
  482.   if (bit_order == MSBFirst) bit_shift -= bits_per_pixel;
  483.                         else bit_shift += bits_per_pixel;
  484.  
  485.   bits_used += bits_per_pixel;
  486.   
  487.   return n;
  488. }
  489.  
  490.  
  491. /***************************/
  492. static int xwdError(st)
  493.      char *st;
  494. {
  495.   if (pic8  != NULL) free(pic8);
  496.   if (pic24 != NULL) free(pic24);
  497.  
  498.   SetISTR(ISTR_WARNING,"%s:  %s", bname, st);
  499.   return 0;
  500. }
  501.  
  502.  
  503. /***************************/
  504. static void xwdWarning(st)
  505.      char *st;
  506. {
  507.   SetISTR(ISTR_WARNING,"%s:  %s", bname, st);
  508. }
  509.  
  510.  
  511.  
  512.  
  513.  
  514. /* 
  515.  * Byte-swapping junk.
  516.  */
  517.  
  518. union cheat {
  519.   CARD32 l;
  520.   CARD16 s;
  521.   CARD8  c[sizeof(CARD32)];
  522. };
  523.  
  524. static int bs_short(s)
  525.      int s;
  526. {
  527.   union cheat u;
  528.   unsigned char t;
  529.  
  530.   u.s = (CARD16) s;
  531.   t = u.c[0];  u.c[0] = u.c[1];  u.c[1] = t;
  532.   return (int) u.s;
  533. }
  534.  
  535. static CARD32 bs_long(l)
  536.      CARD32 l;
  537. {
  538.   union cheat u;
  539.   unsigned char t;
  540.   
  541.   u.l = l;
  542.   t = u.c[0];  u.c[0] = u.c[3];  u.c[3] = t;
  543.   t = u.c[1];  u.c[1] = u.c[2];  u.c[2] = t;
  544.   return u.l;
  545. }
  546.  
  547.  
  548.  
  549.  
  550.  
  551.  
  552. /* 
  553.  * Endian I/O.
  554.  */
  555.  
  556. static int readbigshort(in, sP)
  557.      FILE  *in;
  558.      CARD16 *sP;
  559. {
  560.   *sP = (getc(in) & 0xff) << 8;
  561.   *sP |= getc(in) & 0xff;
  562.  
  563.   if (ferror(in)) return -1;
  564.   return 0;
  565. }
  566.  
  567. static int readbiglong(in, lP)
  568.      FILE *in;
  569.      CARD32 *lP;
  570. {
  571.   *lP  = (getc(in) & 0xff) << 24;
  572.   *lP |= (getc(in) & 0xff) << 16;
  573.   *lP |= (getc(in) & 0xff) << 8;
  574.   *lP |=  getc(in) & 0xff;
  575.  
  576.   if (ferror(in)) return -1;
  577.   return 0;
  578. }
  579.  
  580.  
  581. static int readlittleshort(in, sP)
  582.      FILE  *in;
  583.      CARD16 *sP;
  584. {
  585.   *sP  =  getc(in) & 0xff;
  586.   *sP |= (getc(in) & 0xff) << 8;
  587.   
  588.   if (ferror(in)) return -1;
  589.   return 0;
  590. }
  591.  
  592.  
  593. static int readlittlelong(in, lP)
  594.      FILE *in;
  595.      CARD32 *lP;
  596. {
  597.   *lP  =  getc(in) & 0xff;
  598.   *lP |= (getc(in) & 0xff) << 8;
  599.   *lP |= (getc(in) & 0xff) << 16;
  600.   *lP |= (getc(in) & 0xff) << 24;
  601.  
  602.   if (ferror(in)) return -1;
  603.   return 0;
  604. }
  605.  
  606.  
  607. static int writebiglong(out, l)
  608.      FILE* out;
  609.      CARD32 l;
  610. {
  611.   putc((l>>24) & 0xff, out);
  612.   putc((l>>16) & 0xff, out);
  613.   putc((l>> 8) & 0xff, out);
  614.   putc( l      & 0xff, out);
  615.   return 0;
  616. }
  617.  
  618.  
  619. static int writebigshort(out, s)
  620.      FILE* out;
  621.      int   s;
  622. {
  623.   putc((s>>8)&0xff, out);
  624.   putc(s&0xff, out);
  625.   return 0;
  626. }