home *** CD-ROM | disk | FTP | other *** search
/ ARM Club 3 / TheARMClub_PDCD3.iso / hensa / maths / plplot / plplot_2 / sys / amiga / src / plsupport. < prev   
Encoding:
Text File  |  1994-05-23  |  17.7 KB  |  719 lines
  1. /* $Id: plsupport.c,v 1.7 1994/05/23 22:12:00 mjl Exp $
  2.    $Log: plsupport.c,v $
  3.  * Revision 1.7  1994/05/23  22:12:00  mjl
  4.  * Minor incompatibilities with main sources fixed.
  5.  *
  6.  * Revision 1.6  1994/03/23  08:56:30  mjl
  7.  * Header file rearrangement.
  8.  *
  9.  * Revision 1.5  1993/07/01  21:59:55  mjl
  10.  * Changed all plplot source files to include plplotP.h (private) rather than
  11.  * plplot.h.  Rationalized namespace -- all externally-visible plplot functions
  12.  * now start with "pl"; device driver functions start with "plD_".
  13.  *
  14.  * Revision 1.4  1993/03/15  21:34:29  mjl
  15.  * Reorganization and update of Amiga drivers.  Window driver now uses Amiga
  16.  * OS 2.0 capabilities.
  17.  *
  18.  * Revision 1.3  1993/01/23  06:12:48  mjl
  19.  * Preliminary work on new graphical interface (2.04-specific) for the Amiga.
  20.  *
  21.  * Revision 1.2  1992/10/12  17:11:27  mjl
  22.  * Amiga-specific mods, including ANSI-fication.
  23.  *
  24.  * Revision 1.1  1992/05/20  21:35:29  furnish
  25.  * Initial checkin of the whole PLPLOT project.
  26.  *
  27. */
  28.  
  29. #include "plplotP.h"
  30. #include "plamiga.h"
  31.  
  32. #include <stdlib.h>
  33. #include <string.h>
  34. #include <exec/memory.h>
  35. #include <devices/printer.h>
  36. #include <devices/prtbase.h>
  37. #include <libraries/dosextens.h>
  38. #include <proto/exec.h>
  39.  
  40. /*----------------------------------------------------------------------*\
  41. * Bitmap builders
  42. \*----------------------------------------------------------------------*/
  43.  
  44. static struct BitMap Bitmap;
  45. static long bitmapx, bitmapy, wordsperrow;
  46. static short *bitmap;
  47.  
  48. /* Functions */
  49.  
  50. int  mapinit    (long, long);
  51. void mapline    (register int, register int, register int, register int);
  52. void mapfree    (void);
  53. void mapclear    (void);
  54.  
  55. /*----------------------------------------------------------------------*\
  56. * mapinit
  57. * 
  58. * Allocate bitmap.
  59. \*----------------------------------------------------------------------*/
  60.  
  61. int 
  62. mapinit(long bmapx, long bmapy)
  63. {
  64.     bitmapx = bmapx;
  65.     bitmapy = bmapy;
  66.     wordsperrow = (bmapx + 15) / 16;
  67.     Bitmap.BytesPerRow = wordsperrow * 2;
  68.     Bitmap.Rows = bmapy;
  69.     /* Allocate memory for bitmap */
  70.     if ((bitmap = (short *) calloc(wordsperrow * 2, (int) bmapy)) == NULL) {
  71.     fprintf(stderr, "\nCan't allocate memory for bitmap dump.\n");
  72.     return (1);
  73.     }
  74.     Bitmap.Planes[0] = (PLANEPTR) bitmap;
  75.     return (0);
  76. }
  77.  
  78. /*----------------------------------------------------------------------*\
  79. * mapline
  80. * 
  81. * Draw a line in the bitmap.
  82. \*----------------------------------------------------------------------*/
  83.  
  84. void 
  85. mapline(register int x1, register int y1, register int x2, register int y2)
  86. {
  87.     register short *p;
  88.     register unsigned int b;
  89.     register int t;
  90.     int d;
  91.     int nextrow;
  92.  
  93.     /* we always want to go left to right. */
  94.     if (x1 > x2) {
  95.     t = x1;
  96.     x1 = x2;
  97.     x2 = t;
  98.     t = y1;
  99.     y1 = y2;
  100.     y2 = t;
  101.     }
  102.     p = bitmap + y1 * wordsperrow;
  103.     /* we always want to go `up'. */
  104.     if (y2 > y1)
  105.     nextrow = wordsperrow;
  106.     else {
  107.     y2 = y1 * 2 - y2;
  108.     nextrow = -wordsperrow;
  109.     }
  110.     b = 1L << (15 - (x1 & 15));
  111.     p += (x1 >> 4);
  112.     x2 -= x1;
  113.     y2 -= y1;
  114.     /* two routines, one for major in x, one for major in y */
  115.     if (y2 > x2) {
  116.     d = y2;
  117.     t = x2 / 2;
  118.     y1 = y2;
  119.     while (y1 >= 0) {
  120.         *p |= b;
  121.         p += nextrow;
  122.         t += x2;
  123.         if (t >= d) {
  124.         t -= d;
  125.         b >>= 1;
  126.         if (b == 0) {
  127.             b = 0x8000;
  128.             p++;
  129.         }
  130.         }
  131.         y1--;
  132.     }
  133.     }
  134.     else {
  135.     d = x2;
  136.     t = y2 / 2;
  137.     x1 = x2;
  138.     while (x1 >= 0) {
  139.         *p |= b;
  140.         b >>= 1;
  141.         if (b == 0) {
  142.         b = 0x8000;
  143.         p++;
  144.         }
  145.         t += y2;
  146.         if (t >= d) {
  147.         t -= d;
  148.         p += nextrow;
  149.         }
  150.         x1--;
  151.     }
  152.     }
  153. }
  154.  
  155. /*----------------------------------------------------------------------*\
  156. * mapfree  -- deallocate bitmap.
  157. * mapclear -- 0-fill bitmap.
  158. \*----------------------------------------------------------------------*/
  159.  
  160. void 
  161. mapfree(void)
  162. {
  163.     free((VOID *) bitmap);
  164. }
  165.  
  166. void 
  167. mapclear(void)
  168. {
  169.     memset((char *) bitmap, '\0', (int) (wordsperrow * (long) bitmapy * 2));
  170. }
  171.  
  172. /*----------------------------------------------------------------------*\
  173. * Printer utility routines
  174. \*----------------------------------------------------------------------*/
  175.  
  176. static union printerIO {
  177.     struct IOStdReq ios;
  178.     struct IODRPReq iodrp;
  179.     struct IOPrtCmdReq iopc;
  180. } *printerIO;
  181.  
  182. static struct PrinterData *PD;
  183. static struct PrinterExtendedData *PED;
  184. static struct MsgPort *replyport;
  185. static struct RastPort rastport;
  186.  
  187. static short dummycolors[] =
  188. {0x0000, 0x0fff};
  189. static struct ColorMap dummyColorMap =
  190. {NULL, NULL, 2, (APTR) & dummycolors};
  191.  
  192. /* Functions */
  193.  
  194. static void doio    (void);
  195.  
  196. int  queryprint        (long *, long *, long *, long *, long *, long *);
  197. int  openprinter    (void);
  198. void closeprinter    (void);
  199. void ejectpage        (void);
  200. void dmpport        (long, int, int);
  201. void screendump        (PLINT);
  202.  
  203. /*----------------------------------------------------------------------*\
  204. * queryprint
  205. * 
  206. * Get preferences printer settings.
  207. \*----------------------------------------------------------------------*/
  208.  
  209. int 
  210. queryprint(long *bmapx, long *bmapy, long *bmapxmax, long *bmapymax, 
  211.        long *xdpi, long *ydpi)
  212. {
  213.     int mode;
  214.     Bitmap.BytesPerRow = 0;
  215.     Bitmap.Rows = 0;
  216.     Bitmap.Depth = 1;
  217.     rastport.BitMap = &Bitmap;
  218.     dmpport((long) (SPECIAL_NOPRINT), 0, 0);
  219.  
  220.     *bmapxmax = PED->ped_MaxXDots;
  221.     *bmapymax = 95 * PED->ped_YDotsInch / 10;    /* 9.5in to prevent problems */
  222.  
  223.     *xdpi = PED->ped_XDotsInch;
  224.     *ydpi = PED->ped_YDotsInch;
  225.  
  226.     if (PD->pd_Preferences.PrintFlags & BOUNDED_DIMENSIONS) {
  227.     *bmapx = PD->pd_Preferences.PrintMaxWidth * PED->ped_XDotsInch / 10;
  228.     *bmapy = PD->pd_Preferences.PrintMaxHeight * PED->ped_YDotsInch / 10;
  229.     mode = 1;
  230.     }
  231.     else if (PD->pd_Preferences.PrintFlags & ABSOLUTE_DIMENSIONS) {
  232.     *bmapx = PD->pd_Preferences.PrintMaxWidth * PED->ped_XDotsInch / 10;
  233.     *bmapy = PD->pd_Preferences.PrintMaxHeight * PED->ped_YDotsInch / 10;
  234.     mode = 0;
  235.     }
  236.     else if (PD->pd_Preferences.PrintFlags & PIXEL_DIMENSIONS) {
  237.     *bmapx = PD->pd_Preferences.PrintMaxWidth;
  238.     *bmapy = PD->pd_Preferences.PrintMaxHeight;
  239.     mode = 0;
  240.     }
  241.     else {
  242.     *bmapx = *bmapxmax;
  243.     *bmapy = *bmapymax;
  244.     mode = 1;
  245.     }
  246.  
  247.     PD->pd_Preferences.PrintImage = IMAGE_NEGATIVE;
  248.     PD->pd_Preferences.PrintShade = SHADE_BW;
  249.     PD->pd_Preferences.PrintThreshold = 7;
  250.     PD->pd_Preferences.PrintAspect = ASPECT_HORIZ;
  251.     PD->pd_Preferences.PrintFlags = INTEGER_SCALING;
  252.     return (mode);
  253. }
  254.  
  255. /*----------------------------------------------------------------------*\
  256. * openprinter
  257. * 
  258. * Set up for printer dump.
  259. \*----------------------------------------------------------------------*/
  260.  
  261. int 
  262. openprinter(void)
  263. {
  264.     replyport = (struct MsgPort *) CreatePort("PLPlot.PIO", 0L);
  265.     if (replyport == NULL) {
  266.     fprintf(stderr, "Couldn't open reply port for printer dump.\n");
  267.     return (1);
  268.     }
  269.  
  270.     printerIO = (union printerIO *)
  271.     AllocMem((long) sizeof(union printerIO),
  272.          (long) (MEMF_CLEAR | MEMF_PUBLIC));
  273.     if (printerIO == NULL) {
  274.     DeletePort(replyport);
  275.     fprintf(stderr, "Couldn't create IO request block for printer dump.\n");
  276.     return (1);
  277.     }
  278.     printerIO->ios.io_Message.mn_Node.ln_Type = NT_MESSAGE;
  279.     printerIO->ios.io_Message.mn_Length = sizeof(union printerIO);
  280.     printerIO->ios.io_Message.mn_ReplyPort = replyport;
  281.  
  282.     if (OpenDevice("printer.device", 0L, (struct IORequest *) printerIO, 0L) != NULL) {
  283.     FreeMem((VOID *) printerIO, (long) sizeof(union printerIO));
  284.     DeletePort(replyport);
  285.     fprintf(stderr, "Error opening printer device.\n");
  286.     return (1);
  287.     }
  288.  
  289.     PD = (struct PrinterData *) printerIO->iodrp.io_Device;
  290.     PED = &PD->pd_SegmentData->ps_PED;
  291.     return (0);
  292. }
  293.  
  294. /*----------------------------------------------------------------------*\
  295. * closeprinter -- Free resources used in printer dump.
  296. * ejectpage    -- Send a page eject command to printer.
  297. \*----------------------------------------------------------------------*/
  298.  
  299. void 
  300. closeprinter(void)
  301. {
  302.     CloseDevice((struct IORequest *) printerIO);
  303.     FreeMem((VOID *) printerIO, (long) sizeof(union printerIO));
  304.     DeletePort(replyport);
  305. }
  306.  
  307. void 
  308. ejectpage(void)
  309. {
  310.     printerIO->ios.io_Command = PRD_RAWWRITE;
  311.     printerIO->ios.io_Data = (APTR) "\014";
  312.     printerIO->ios.io_Length = 1;
  313.     doio();
  314. }
  315.  
  316. /*----------------------------------------------------------------------*\
  317. * doio
  318. * 
  319. * Send off an i/o request.
  320. \*----------------------------------------------------------------------*/
  321.  
  322. static void 
  323. doio(void)
  324. {
  325.     register struct IODRPReq *ioreq;
  326.  
  327.     ioreq = &printerIO->iodrp;
  328.     SendIO((struct IORequest *) ioreq);
  329.     while (1) {
  330.     if (GetMsg(replyport) == NULL)
  331.         Wait(1L << replyport->mp_SigBit);
  332.     else
  333.         break;
  334.     }
  335. }
  336.  
  337. /*----------------------------------------------------------------------*\
  338. * dmpport
  339. * 
  340. * Dump a bitmap to the printer.
  341. \*----------------------------------------------------------------------*/
  342.  
  343. void 
  344. dmpport(long flags, int x, int y)
  345. {
  346.     register struct IODRPReq *ioreq;
  347.  
  348.     ioreq = &printerIO->iodrp;
  349.     ioreq->io_Command = PRD_DUMPRPORT;
  350.     ioreq->io_RastPort = &rastport;
  351.     ioreq->io_ColorMap = &dummyColorMap;
  352.     ioreq->io_Modes = 0;
  353.     ioreq->io_SrcX = 0;
  354.     ioreq->io_SrcY = 0;
  355.     ioreq->io_SrcWidth = x;
  356.     ioreq->io_SrcHeight = y;
  357.     ioreq->io_DestCols = x;
  358.     ioreq->io_DestRows = y;
  359.     ioreq->io_Special = flags | SPECIAL_TRUSTME;
  360.     doio();
  361. }
  362.  
  363. /*----------------------------------------------------------------------*\
  364. * screendump
  365. *
  366. * If type = 0 dump the plplot window to the printer with full preferences
  367. * support, i.e. color, shading, threshold, etc.  Otherwise we override many
  368. * of the preferences selections, create a full page black and white bitmap
  369. * and dump it to the printer.
  370. \*----------------------------------------------------------------------*/
  371.  
  372. void 
  373. screendump(PLINT type)
  374. {
  375.     register struct IODRPReq *ioreq;
  376.     long bmapx, bmapy;
  377.     long dwidth, dheight;
  378.  
  379.     if (type != 0)        /* originally also had  && fbuffer == 0 */
  380.     return;
  381.     if (openprinter())        /* return if error */
  382.     return;
  383.  
  384.     ioreq = &printerIO->iodrp;
  385.  
  386. /* INDENT OFF */
  387.  
  388.     if (type == 0) {
  389.     ioreq->io_Command    = PRD_DUMPRPORT;
  390.     ioreq->io_RastPort    = pla->WRPort;
  391.     ioreq->io_ColorMap    = pla->screen->ViewPort.ColorMap;
  392.     ioreq->io_Modes        = pla->screen->ViewPort.Modes;
  393.     ioreq->io_SrcX        = pla->xoffset;
  394.     ioreq->io_SrcY        = pla->yoffset;
  395.     ioreq->io_SrcWidth    = pla->cur_width;
  396.     ioreq->io_SrcHeight    = pla->cur_height;
  397.     ioreq->io_DestCols    = 0;
  398.     ioreq->io_DestRows    = 0;
  399.     ioreq->io_Special    = SPECIAL_FULLROWS | SPECIAL_FULLCOLS |
  400.                               SPECIAL_TRUSTME;
  401. /* INDENT ON */
  402.  
  403.     doio();
  404.     }
  405. #if 0
  406.     else {
  407.  
  408. /* get bmapx and bmapy (the others are dummy variables) */
  409.  
  410.     queryprint(&bmapx, &bmapy, &dwidth, &dheight, &dwidth, &dheight);
  411.  
  412. /* Set up map */
  413.  
  414.     if (mapinit(bmapx, bmapy)) {
  415.         closeprinter();
  416.         return;
  417.     }
  418.  
  419.     dwidth = bmapx - 2;
  420.     dheight = bmapy - 2;
  421.  
  422. /* PUT PLOT BUFFER READ HERE */
  423. /* NEED TO CALL MAPLINE AS NECESSARY -- SEE OLD CODE */
  424.  
  425.     dmpport(0L, bmapx, bmapy);
  426.     mapfree();
  427.     }
  428. #endif
  429.     closeprinter();
  430. }
  431.  
  432. /*----------------------------------------------------------------------*\
  433. * IFF file manipulators
  434. \*----------------------------------------------------------------------*/
  435.  
  436. #define BADFLAGS    (SPRITES|VP_HIDE|GENLOCK_AUDIO|GENLOCK_VIDEO)
  437. #define FLAGMASK    (~BADFLAGS)
  438. #define CAMGMASK    (FLAGMASK & 0x0000FFFFL)
  439.  
  440. struct BitMapHeader {
  441.     UWORD w, h;
  442.     WORD x, y;
  443.     UBYTE nPlanes;
  444.     UBYTE masking;
  445.     UBYTE compression;
  446.     UBYTE pad1;
  447.     UWORD transparentColor;
  448.     UBYTE xAspect, yAspect;
  449.     WORD pageWidth, pageHeight;
  450. } bmhd;
  451.  
  452. /* Header for a B&W IFF image file. */
  453.  
  454. static struct iffhead {
  455.     char formname[4];
  456.     long formlen;        /* fill me in */
  457.     char ilbmname[4];
  458.     char bmhdname[4];
  459.     long bmhdlen;
  460.     short w, h;            /* fill me in */
  461.     long dummy0;
  462.     char numplanes, masking, compression, pad1;
  463.     short tc;
  464.     char xas, yas;
  465.     short pw, ph;
  466.     char cmapname[4];
  467.     long cmaplen;
  468.     unsigned char r0, g0, b0, r1, g1, b1;
  469.     char bodyname[4];
  470.     long bodylen;        /* fill me in */
  471. } iffhead = { {'F','O','R','M'}, 0, {'I','L','B','M'}, {'B','M','H','D'}, 20,
  472.       0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 320, 200, {'C','M','A','P'}, 6, 240, 240,
  473.       240, 0, 0, 0, {'B','O','D','Y'}, 0 } ;
  474.  
  475. static long iffpos;
  476. static short curbyte;
  477. static short curcount;
  478. static short runcount;
  479. static FILE *OutFile;
  480.  
  481. char outchunk[256];
  482.  
  483. /* Function prototypes */
  484.  
  485. static void iffobyte    (register int);
  486. static void iffoutbyte    (register int);
  487. static void finishrow    (void);
  488.  
  489. void iffwritefile    (PLINT, PLINT, FILE *);
  490. int  saveiff        (char *);
  491.  
  492. /*----------------------------------------------------------------------*\
  493. * saveiff
  494. *
  495. * Writes out color bitmap.
  496. \*----------------------------------------------------------------------*/
  497.  
  498. int
  499. saveiff(char *filename)
  500. {
  501.     long int formlen = 0, formpos, bmhdlen, camglen, camgbod;
  502.     long int bodylen = 0, bodypos, cmaplen;
  503.     long int numcolors, rowlen, rowoff, coloff;
  504.     short int i, j, k;
  505.     UWORD *coltable;
  506.     UBYTE *byteptr, rgb[3];
  507.     struct BitMap *PLBitMap;
  508.     FILE *IFFFile;
  509.  
  510.     if ((IFFFile = fopen(filename, "w+")) == NULL) 
  511.     return (1);
  512.  
  513.     iffpos = 0;
  514.     curbyte = -1;
  515.     curcount = 0;
  516.     runcount = 0;
  517.     OutFile = IFFFile;
  518.  
  519.     bmhdlen = sizeof(struct BitMapHeader);
  520.     camglen = 4;
  521.     PLBitMap = &pla->screen->BitMap;
  522.  
  523.     fwrite("FORM", sizeof(char), 4, IFFFile);
  524.     formpos = ftell(IFFFile);
  525.     fwrite((char *) &formlen, sizeof(long), 1, IFFFile);
  526.  
  527.     fwrite("ILBM", sizeof(char), 4, IFFFile);
  528.     formlen += 4;
  529.  
  530.     fwrite("BMHD", sizeof(char), 4, IFFFile);
  531.     formlen += 4;
  532.     fwrite((char *) &bmhdlen, sizeof(long), 1, IFFFile);
  533.     formlen += 4;
  534.     bmhd.w = 16 * ((pla->cur_width + 15) / 16);
  535.     bmhd.h = pla->cur_height;
  536.     bmhd.x = pla->window->LeftEdge + pla->xoffset;
  537.     bmhd.y = pla->window->TopEdge + pla->yoffset;
  538.     bmhd.nPlanes = PLBitMap->Depth;
  539.     bmhd.masking = 0;
  540.     bmhd.compression = 1;
  541.     bmhd.pad1 = 0;
  542.     bmhd.transparentColor = 0;
  543.     bmhd.xAspect = 10;
  544.     bmhd.yAspect = 11;
  545.     bmhd.pageWidth = pla->screen->Width;
  546.     bmhd.pageHeight = pla->screen->Height;
  547.     fwrite((char *) &bmhd, bmhdlen, 1, IFFFile);
  548.     formlen += bmhdlen;
  549.  
  550.     fwrite("CAMG", sizeof(char), 4, IFFFile);
  551.     formlen += 4;
  552.     fwrite((char *) &camglen, sizeof(long), 1, IFFFile);
  553.     formlen += 4;
  554.     camgbod = pla->screen->ViewPort.Modes & CAMGMASK;
  555.     fwrite((char *) &camgbod, sizeof(long), 1, IFFFile);
  556.     formlen += 4;
  557.  
  558.     fwrite("CMAP", sizeof(char), 4, IFFFile);
  559.     formlen += 4;
  560.     numcolors = 1;
  561.     for (i = PLBitMap->Depth; i > 0; i--)
  562.     numcolors *= 2;
  563.     cmaplen = numcolors * 3;
  564.     fwrite((char *) &cmaplen, sizeof(long), 1, IFFFile);
  565.     formlen += 4;
  566.     coltable = (UWORD *) pla->CMap->ColorTable;
  567.     for (i = 0; i < numcolors; i++) {
  568.     rgb[0] = (*coltable >> 4) & 0xf0;
  569.     rgb[1] = *coltable & 0xf0;
  570.     rgb[2] = (*coltable << 4) & 0xf0;
  571.     fwrite((char *) rgb, sizeof(UBYTE), 3, IFFFile);
  572.     formlen += 3;
  573.     coltable++;
  574.     }
  575.  
  576.     fwrite("BODY", sizeof(char), 4, IFFFile);
  577.     formlen += 4;
  578.     bodypos = ftell(IFFFile);
  579.     fwrite((char *) &bodylen, sizeof(long), 1, IFFFile);
  580.     formlen += 4;
  581.     rowlen = ((pla->cur_width + 15) / 16);
  582.     rowlen *= 2;
  583.     rowoff = (pla->window->TopEdge + pla->yoffset) * PLBitMap->BytesPerRow;
  584.     coloff = (pla->window->LeftEdge + pla->xoffset) / 8;
  585.     for (i = 0; i < pla->cur_height; i++) {
  586.     for (j = 0; j < PLBitMap->Depth; j++) {
  587.         byteptr = (UBYTE *) PLBitMap->Planes[j] + rowoff + coloff;
  588.         for (k = 0; k < rowlen; k++)
  589.         iffoutbyte(*byteptr++ & 255);
  590.         finishrow();
  591.     }
  592.     rowoff += PLBitMap->BytesPerRow;
  593.     }
  594.     if (iffpos & 1)
  595.     iffobyte(0);
  596.     bodylen = iffpos;
  597.     formlen += iffpos;
  598.     fflush(IFFFile);
  599.     fseek(IFFFile, formpos, 0);
  600.     fwrite((char *) &formlen, sizeof(long), 1, IFFFile);
  601.     fseek(IFFFile, bodypos, 0);
  602.     fwrite((char *) &bodylen, sizeof(long), 1, IFFFile);
  603.     fclose(IFFFile);
  604.     return (0);
  605. }
  606.  
  607. /*----------------------------------------------------------------------*\
  608. * iffwritefile
  609. *
  610. * Writes out B&W bitmap.
  611. \*----------------------------------------------------------------------*/
  612.  
  613. void 
  614. iffwritefile(PLINT xdpi, PLINT ydpi, FILE *File)
  615. {
  616.     register int i, j;
  617.     register short *p;
  618.  
  619.     p = bitmap;
  620.     OutFile = File;
  621.     fwrite((char *) &iffhead, 1, sizeof(struct iffhead), OutFile);
  622.     iffpos = 0;
  623.     curbyte = -1;
  624.     curcount = 0;
  625.     runcount = 0;
  626.     for (j = 0; j < bitmapy; j++) {
  627.     for (i = wordsperrow; i; i--, p++) {
  628.         iffoutbyte((*p >> 8) & 255);
  629.         iffoutbyte(*p & 255);
  630.     }
  631.     finishrow();
  632.     }
  633.     if (iffpos & 1)
  634.     iffobyte(0);
  635.     fseek(OutFile, 0L, 0);
  636.     iffhead.w = bitmapx;
  637.     iffhead.h = bitmapy;
  638.     iffhead.pw = bitmapx;
  639.     iffhead.ph = bitmapy;
  640.     iffhead.formlen = iffpos + sizeof(struct iffhead) - 8;
  641.     iffhead.bodylen = iffpos;
  642.     iffhead.xas = xdpi;
  643.     iffhead.yas = ydpi;
  644.     fwrite((char *) &iffhead, 1, sizeof(struct iffhead), OutFile);
  645. }
  646.  
  647. /*----------------------------------------------------------------------*\
  648. * IFF utility routines
  649. \*----------------------------------------------------------------------*/
  650.  
  651. static void 
  652. iffobyte(register int b)
  653. {
  654.     putc(b, OutFile);
  655.     iffpos++;
  656. }
  657.  
  658. static void 
  659. iffoutbyte(register int b)
  660. {
  661.     register int i;
  662.  
  663.     if (b == curbyte && runcount < 125) {
  664.     runcount++;
  665.     }
  666.     else {
  667.     if (runcount > 2) {
  668.         if (curcount > 0) {
  669.         iffobyte(curcount - 1);
  670.         for (i = 0; i < curcount; i++)
  671.             iffobyte(outchunk[i]);
  672.         curcount = 0;
  673.         }
  674.         iffobyte(256 - runcount + 1);
  675.         iffobyte(curbyte);
  676.     }
  677.     else {
  678.         while (runcount > 0) {
  679.         outchunk[curcount++] = curbyte;
  680.         runcount--;
  681.         }
  682.         if (curcount > 110) {
  683.         iffobyte(curcount - 1);
  684.         for (i = 0; i < curcount; i++)
  685.             iffobyte(outchunk[i]);
  686.         curcount = 0;
  687.         }
  688.     }
  689.     curbyte = b;
  690.     runcount = 1;
  691.     }
  692. }
  693.  
  694. static void 
  695. finishrow(void)
  696. {
  697.     register int i;
  698.  
  699.     if (runcount <= 2) {
  700.     while (runcount > 0) {
  701.         outchunk[curcount++] = curbyte;
  702.         runcount--;
  703.     }
  704.     }
  705.     if (curcount > 0) {
  706.     iffobyte(curcount - 1);
  707.     for (i = 0; i < curcount; i++)
  708.         iffobyte(outchunk[i]);
  709.     curcount = 0;
  710.     }
  711.     if (runcount > 0) {
  712.     iffobyte(256 - runcount + 1);
  713.     iffobyte(curbyte);
  714.     curbyte = -1;
  715.     runcount = 0;
  716.     }
  717. }
  718.  
  719.